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_box_pack_start(GTK_BOX(event_viewer_data->hbox_v), event_viewer_data->vscroll_vc, FALSE, TRUE, 0);
 398
 399   /* Get the vertical scrollbar's adjustment */
 400   event_viewer_data->vadjust_c = gtk_range_get_adjustment(GTK_RANGE(event_viewer_data->vscroll_vc));
 401   event_viewer_data->vtree_adjust_c = gtk_tree_view_get_vadjustment(
 402                                                                     GTK_TREE_VIEW (event_viewer_data->tree_v));
 403
 404   g_signal_connect (G_OBJECT (event_viewer_data->vadjust_c), "value-changed",
 405                     G_CALLBACK (v_scroll_cb),
 406                     event_viewer_data);
 407   /* Set the upper bound to the last event number */
 408   event_viewer_data->previous_value = 0;
 409   event_viewer_data->vadjust_c->lower = 0.0;
 410     //event_viewer_data->vadjust_c->upper = event_viewer_data->number_of_events;
 411   event_viewer_data->vadjust_c->value = 0.0;
 412   event_viewer_data->vadjust_c->step_increment = 1.0;
 413   event_viewer_data->vadjust_c->page_increment = 2.0;
 414     //  event_viewer_data->vtree_adjust_c->upper;
 415   event_viewer_data->vadjust_c->page_size = 2.0;
 416   //    event_viewer_data->vtree_adjust_c->upper;
 417   /*  Raw event trace */
 418   gtk_widget_show(event_viewer_data->hbox_v);
 419   gtk_widget_show(event_viewer_data->tree_v);
 420   gtk_widget_show(event_viewer_data->vscroll_vc);
 421
 422   /* Add the object's information to the module's array */
 423   g_event_viewer_data_list = g_slist_append(g_event_viewer_data_list, event_viewer_data);
 424
 425   event_viewer_data->first_event = -1 ;
 426   event_viewer_data->last_event = 0 ;
 427
 428   event_viewer_data->num_visible_events = 1;
 429
 430   //get the life span of the traceset and set the upper of the scroll bar
 431   get_traceset_time_span(event_viewer_data->mw, &event_viewer_data->time_span);
 432
 433   start = ltt_time_sub(event_viewer_data->time_span.endTime, event_viewer_data->time_span.startTime);
 434   event_viewer_data->vadjust_c->upper = ltt_time_to_double(start) * NANOSECONDS_PER_SECOND;
 435
 436   event_viewer_data->append = TRUE;
 437
 438   start.tv_sec = 0;
 439   start.tv_nsec = 0;
 440   end.tv_sec = G_MAXULONG;
 441   end.tv_nsec = G_MAXULONG;
 442
 443   get_events(event_viewer_data, start,end, RESERVE_SMALL_SIZE, &size);
 444
 445   event_viewer_data->start_event_index = 0;
 446   event_viewer_data->end_event_index   = event_viewer_data->num_visible_events - 1;
 447
 448   // Test data
 449   get_test_data(event_viewer_data->vadjust_c->value,
 450                 event_viewer_data->num_visible_events,
 451                 event_viewer_data);
 452
 453   /* Set the Selected Event */
 454   //  tree_v_set_cursor(event_viewer_data);
 455
 456
 457   g_object_set_data_full(
 458                         G_OBJECT(event_viewer_data->hbox_v),
 459                         "event_viewer_data",
 460                         event_viewer_data,
 461                         (GDestroyNotify)gui_events_free);
 462
 463   return event_viewer_data;
 464 }
 465
 466 void tree_v_set_cursor(EventViewerData *event_viewer_data)
 467 {
 468   GtkTreePath *path;
 469
 470   if(event_viewer_data->selected_event && event_viewer_data->first_event != -1)
 471     {
 472       //      gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 473      //                        event_viewer_data->currently_selected_event);
 474
 475       path = gtk_tree_path_new_from_indices(
 476                                             event_viewer_data->currently_selected_event-
 477                                             event_viewer_data->first_event,
 478                                             -1);
 479
 480       gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 481       gtk_tree_path_free(path);
 482     }
 483 }
 484
 485 void tree_v_get_cursor(EventViewerData *event_viewer_data)
 486 {
 487   GtkTreePath *path;
 488   gint *indices;
 489
 490   gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), &path, NULL);
 491   indices = gtk_tree_path_get_indices(path);
 492
 493   if(indices != NULL)
 494     {
 495       event_viewer_data->selected_event = TRUE;
 496       event_viewer_data->currently_selected_event =
 497         event_viewer_data->first_event + indices[0];
 498
 499     } else {
 500       event_viewer_data->selected_event = FALSE;
 501       event_viewer_data->currently_selected_event = 0;
 502     }
 503
 504   gtk_tree_path_free(path);
 505
 506 }
 507
 508
 509
 510 void tree_v_move_cursor_cb (GtkWidget *widget, GtkMovementStep arg1, gint arg2, gpointer data)
 511 {
 512   GtkTreePath *path; // = gtk_tree_path_new();
 513   gint *indices;
 514   gdouble value;
 515   EventViewerData *event_viewer_data = (EventViewerData*)data;
 516
 517   gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), &path, NULL);
 518   if(path == NULL)
 519     {
 520       /* No prior cursor, put it at beginning of page and let the execution do */
 521       path = gtk_tree_path_new_from_indices(0, -1);
 522       gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 523     }
 524
 525   indices = gtk_tree_path_get_indices(path);
 526
 527   value = gtk_adjustment_get_value(event_viewer_data->vadjust_c);
 528
 529   if(arg1 == GTK_MOVEMENT_DISPLAY_LINES)
 530     {
 531       /* Move one line */
 532       if(arg2 == 1)
 533         {
 534           /* move one line down */
 535           if(indices[0] == event_viewer_data->num_visible_events - 1)
 536             {
 537               if(value + event_viewer_data->num_visible_events <=
 538                  event_viewer_data->number_of_events -1)
 539                 {
 540                   event_viewer_data->currently_selected_event += 1;
 541                   //              gtk_adjustment_set_value(event_viewer_data->vadjust_c, value+1);
 542                   //gtk_tree_path_free(path);
 543                   //path = gtk_tree_path_new_from_indices(event_viewer_data->num_visible_events-1, -1);
 544                   //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 545                   g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 546                 }
 547             }
 548         } else {
 549           /* Move one line up */
 550           if(indices[0] == 0)
 551             {
 552               if(value - 1 >= 0 )
 553                 {
 554                   event_viewer_data->currently_selected_event -= 1;
 555                   //              gtk_adjustment_set_value(event_viewer_data->vadjust_c, value-1);
 556                   //gtk_tree_path_free(path);
 557                   //path = gtk_tree_path_new_from_indices(0, -1);
 558                   //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 559                   g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 560                 }
 561
 562             }
 563         }
 564
 565     }
 566
 567   if(arg1 == GTK_MOVEMENT_PAGES)
 568     {
 569       /* Move one page */
 570       if(arg2 == 1)
 571         {
 572           if(event_viewer_data->num_visible_events == 1)
 573             value += 1 ;
 574           /* move one page down */
 575           if(value + event_viewer_data->num_visible_events-1 <=
 576              event_viewer_data->number_of_events )
 577             {
 578               event_viewer_data->currently_selected_event += event_viewer_data->num_visible_events-1;
 579               //              gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 580               //                                       value+(event_viewer_data->num_visible_events-1));
 581               //gtk_tree_path_free(path);
 582               //path = gtk_tree_path_new_from_indices(0, -1);
 583               //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 584               g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 585             }
 586         } else {
 587           /* Move one page up */
 588           if(event_viewer_data->num_visible_events == 1)
 589             value -= 1 ;
 590
 591           if(indices[0] < event_viewer_data->num_visible_events - 2 )
 592             {
 593               if(value - (event_viewer_data->num_visible_events-1) >= 0)
 594                 {
 595                   event_viewer_data->currently_selected_event -= event_viewer_data->num_visible_events-1;
 596
 597                   //              gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 598                   //                                       value-(event_viewer_data->num_visible_events-1));
 599                   //gtk_tree_path_free(path);
 600                   //path = gtk_tree_path_new_from_indices(0, -1);
 601                   //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 602                   g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 603
 604                 } else {
 605                   /* Go to first Event */
 606                   event_viewer_data->currently_selected_event == 0 ;
 607                   //              gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 608                   //                                       0);
 609                   //gtk_tree_path_free(path);
 610                   //path = gtk_tree_path_new_from_indices(0, -1);
 611                   //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 612                   g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 613
 614                 }
 615             }
 616
 617         }
 618
 619     }
 620
 621   if(arg1 == GTK_MOVEMENT_BUFFER_ENDS)
 622     {
 623       /* Move to the ends of the buffer */
 624       if(arg2 == 1)
 625         {
 626           /* move end of buffer */
 627           event_viewer_data->currently_selected_event = event_viewer_data->number_of_events-1 ;
 628           //      gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 629           //                               event_viewer_data->number_of_events -
 630           //                               event_viewer_data->num_visible_events);
 631           //gtk_tree_path_free(path);
 632           //path = gtk_tree_path_new_from_indices(event_viewer_data->num_visible_events-1, -1);
 633           //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 634           g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 635         } else {
 636           /* Move beginning of buffer */
 637           event_viewer_data->currently_selected_event = 0 ;
 638           //      gtk_adjustment_set_value(event_viewer_data->vadjust_c, 0);
 639                         //gtk_tree_path_free(path);
 640                         //path = gtk_tree_path_new_from_indices(0, -1);
 641                         //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 642           g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 643         }
 644
 645     }
 646
 647
 648   gtk_tree_path_free(path);
 649 }
 650
 651 void tree_v_cursor_changed_cb (GtkWidget *widget, gpointer data)
 652 {
 653   EventViewerData *event_viewer_data = (EventViewerData*) data;
 654   LttTime ltt_time;
 655   guint64 time;
 656   GtkTreeIter iter;
 657   GtkTreeModel* model = GTK_TREE_MODEL(event_viewer_data->store_m);
 658   GtkTreePath *path;
 659
 660   /* On cursor change, modify the currently selected event by calling
 661    * the right API function */
 662   tree_v_get_cursor(event_viewer_data);
 663 /*
 664   gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), &path, NULL);
 665   if(gtk_tree_model_get_iter(model,&iter,path)){
 666     gtk_tree_model_get(model, &iter, TIME_COLUMN, &time, -1);
 667     ltt_time.tv_sec = time / NANOSECONDS_PER_SECOND;
 668     ltt_time.tv_nsec = time % NANOSECONDS_PER_SECOND;
 669
 670     if(ltt_time.tv_sec != event_viewer_data->current_time.tv_sec ||
 671        ltt_time.tv_nsec != event_viewer_data->current_time.tv_nsec)
 672       set_current_time(event_viewer_data->mw,&ltt_time);
 673   }else{
 674     g_warning("Can not get iter\n");
 675   }
 676 */
 677 }
 678
 679
 680 void v_scroll_cb (GtkAdjustment *adjustment, gpointer data)
 681 {
 682   EventViewerData *event_viewer_data = (EventViewerData*)data;
 683   GtkTreePath *tree_path;
 684
 685   get_test_data(adjustment->value, event_viewer_data->num_visible_events,
 686                 event_viewer_data);
 687
 688
 689   if(event_viewer_data->currently_selected_event
 690      >= event_viewer_data->first_event
 691      &&
 692      event_viewer_data->currently_selected_event
 693      <= event_viewer_data->last_event
 694      &&
 695      event_viewer_data->selected_event)
 696     {
 697
 698       tree_path = gtk_tree_path_new_from_indices(
 699                                                  event_viewer_data->currently_selected_event-
 700                                                  event_viewer_data->first_event,
 701                                                  -1);
 702
 703       //      gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), tree_path,
 704       //                               NULL, FALSE);
 705       gtk_tree_path_free(tree_path);
 706     }
 707
 708
 709 }
 710
 711 gint get_cell_height(GtkTreeView *TreeView)
 712 {
 713   gint height, width;
 714   GtkTreeViewColumn *column = gtk_tree_view_get_column(TreeView, 0);
 715   GList *Render_List = gtk_tree_view_column_get_cell_renderers(column);
 716   GtkCellRenderer *renderer = g_list_first(Render_List)->data;
 717
 718   gtk_tree_view_column_cell_get_size(column, NULL, NULL, NULL, NULL, &height);
 719
 720   return height;
 721 }
 722
 723 void tree_v_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data)
 724 {
 725   EventViewerData *event_viewer_data = (EventViewerData*)data;
 726   gint cell_height = get_cell_height(GTK_TREE_VIEW(event_viewer_data->tree_v));
 727   gint last_num_visible_events = event_viewer_data->num_visible_events;
 728   gdouble exact_num_visible;
 729
 730   exact_num_visible = ( alloc->height -
 731                         TREE_VIEW_HEADER_HEIGHT (GTK_TREE_VIEW(event_viewer_data->tree_v)) )
 732     / (double)cell_height ;
 733
 734   event_viewer_data->num_visible_events = ceil(exact_num_visible) ;
 735
 736 /*
 737   event_viewer_data->vadjust_c->page_increment =
 738     floor(exact_num_visible);
 739   event_viewer_data->vadjust_c->page_size =
 740     floor(exact_num_visible);
 741 */
 742
 743   if(event_viewer_data->num_visible_events != last_num_visible_events)
 744     {
 745       get_test_data(event_viewer_data->vadjust_c->value,
 746                     event_viewer_data->num_visible_events,
 747                     event_viewer_data);
 748     }
 749
 750
 751 }
 752
 753 void tree_v_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data)
 754 {
 755   gint h;
 756   EventViewerData *event_viewer_data = (EventViewerData*)data;
 757   gint cell_height = get_cell_height(GTK_TREE_VIEW(event_viewer_data->tree_v));
 758
 759   h = cell_height + TREE_VIEW_HEADER_HEIGHT
 760     (GTK_TREE_VIEW(event_viewer_data->tree_v));
 761   requisition->height = h;
 762
 763 }
 764
 765 void get_test_data(double time_value, guint list_height,
 766                    EventViewerData *event_viewer_data)
 767 {
 768   GtkTreeIter iter;
 769   int i;
 770   GtkTreeModel *model = GTK_TREE_MODEL(event_viewer_data->store_m);
 771   GtkTreePath *tree_path;
 772   RawTraceData * raw_data;
 773   ScrollDirection  direction = SCROLL_NONE;
 774   GList * first;
 775   int event_number;
 776   double value = event_viewer_data->previous_value - time_value;
 777   LttTime start, end, time;
 778   LttEvent * ev;
 779   unsigned backward_num, minNum, maxNum;
 780   LttTracefile * tf;
 781   unsigned  block_num, event_num;
 782   unsigned size = 1, count = 0;
 783   gboolean need_backward_again, backward;
 784
 785
 786   //    if(event_number > event_viewer_data->last_event ||
 787   //             event_number + list_height-1 < event_viewer_data->first_event ||
 788   //             event_viewer_data->first_event == -1)
 789   {
 790     /* no event can be reused, clear and start from nothing */
 791     if(value == -1.0)      direction = SCROLL_STEP_DOWN;
 792     else if(value == 1.0 ) direction = SCROLL_STEP_UP;
 793     else if(value == -2.0) direction = SCROLL_PAGE_DOWN;
 794     else if(value == 2.0 ) direction = SCROLL_PAGE_UP;
 795     else if(value == 0.0 ) direction = SCROLL_NONE;
 796     else direction = SCROLL_JUMP;
 797
 798     switch(direction){
 799       case SCROLL_STEP_UP:
 800       case SCROLL_PAGE_UP:
 801         if(direction == SCROLL_PAGE_UP){
 802           backward = list_height>event_viewer_data->start_event_index ? TRUE : FALSE;
 803         }else{
 804           backward = event_viewer_data->start_event_index == 0 ? TRUE : FALSE;
 805         }
 806         if(backward){
 807           event_viewer_data->append = FALSE;
 808           do{
 809             if(direction == SCROLL_PAGE_UP){
 810               minNum = list_height - event_viewer_data->start_event_index ;
 811             }else{
 812               minNum = 1;
 813             }
 814
 815             first = event_viewer_data->raw_trace_data_queue->head;
 816             raw_data = (RawTraceData*)g_list_nth_data(first,0);
 817             end = raw_data->time;
 818             end.tv_nsec--;
 819             ltt_event_position_get(&raw_data->ep, &block_num, &event_num, &tf);
 820             if(size !=0){
 821               if(event_num > minNum){
 822                 backward_num = event_num > RESERVE_SMALL_SIZE
 823                               ? event_num - RESERVE_SMALL_SIZE : 1;
 824                 ltt_event_position_set(&raw_data->ep, block_num, backward_num);
 825                 ltt_tracefile_seek_position(tf, &raw_data->ep);
 826                 ev = ltt_tracefile_read(tf);
 827                 start = ltt_event_time(ev);
 828                 maxNum = G_MAXULONG;
 829               }else{
 830                 if(block_num > 1){
 831                   ltt_event_position_set(&raw_data->ep, block_num-1, 1);
 832                   ltt_tracefile_seek_position(tf, &raw_data->ep);
 833                   ev = ltt_tracefile_read(tf);
 834                   start = ltt_event_time(ev);
 835                 }else{
 836                   start.tv_sec  = 0;
 837                   start.tv_nsec = 0;
 838                 }
 839                 maxNum = G_MAXULONG;
 840               }
 841             }else{
 842               if(block_num > count){
 843                 ltt_event_position_set(&raw_data->ep, block_num-count, 1);
 844                 ltt_tracefile_seek_position(tf, &raw_data->ep);
 845                 ev = ltt_tracefile_read(tf);
 846                 start = ltt_event_time(ev);
 847               }else{
 848                 start.tv_sec  = 0;
 849                 start.tv_nsec = 0;
 850               }
 851               maxNum = G_MAXULONG;
 852             }
 853
 854             event_viewer_data->current_event_index = event_viewer_data->start_event_index;
 855             get_events(event_viewer_data, start, end, maxNum, &size);
 856             event_viewer_data->start_event_index = event_viewer_data->current_event_index;
 857
 858             if(size < minNum && (start.tv_sec !=0 || start.tv_nsec !=0))
 859               need_backward_again = TRUE;
 860             else need_backward_again = FALSE;
 861             if(size == 0){
 862               count++;
 863             }else{
 864               count = 0;
 865             }
 866           }while(need_backward_again);
 867         }
 868         if(direction == SCROLL_STEP_UP)
 869           event_number = event_viewer_data->start_event_index - 1;
 870         else
 871           event_number = event_viewer_data->start_event_index - list_height;
 872         break;
 873       case SCROLL_STEP_DOWN:
 874         if(event_viewer_data->end_event_index == event_viewer_data->number_of_events - 1){
 875           event_viewer_data->append = TRUE;
 876           first = event_viewer_data->raw_trace_data_queue->head;
 877           raw_data = (RawTraceData*)g_list_nth_data(first,event_viewer_data->number_of_events - 1);
 878           start = raw_data->time;
 879           start.tv_nsec++;
 880           end.tv_sec = G_MAXULONG;
 881           end.tv_nsec = G_MAXULONG;
 882           get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE, &size);
 883         }else size = 1;
 884         if(size > 0) event_number = event_viewer_data->start_event_index + 1;
 885         else         event_number = event_viewer_data->start_event_index;
 886         break;
 887       case SCROLL_PAGE_DOWN:
 888         if(event_viewer_data->end_event_index >= event_viewer_data->number_of_events - 1 - list_height){
 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         }
 898         if(list_height <= event_viewer_data->number_of_events - 1 - event_viewer_data->end_event_index)
 899           event_number = event_viewer_data->start_event_index + list_height - 1;
 900         else
 901           event_number = event_viewer_data->number_of_events - 1 - list_height;
 902         break;
 903       case SCROLL_JUMP:
 904         event_viewer_data->append = TRUE;
 905         remove_all_items_from_queue(event_viewer_data->raw_trace_data_queue);
 906         end.tv_sec = G_MAXULONG;
 907         end.tv_nsec = G_MAXULONG;
 908         time = ltt_time_from_double(time_value / NANOSECONDS_PER_SECOND);
 909         start = ltt_time_add(event_viewer_data->time_span.startTime, time);
 910         event_viewer_data->previous_value = time_value;
 911         get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE,&size);
 912         if(size < list_height){
 913           event_viewer_data->append = FALSE;
 914           first = event_viewer_data->raw_trace_data_queue->head;
 915           raw_data = (RawTraceData*)g_list_nth_data(first,0);
 916           end = raw_data->time;
 917           end.tv_nsec--;
 918           ltt_event_position_get(&raw_data->ep, &block_num, &event_num, &tf);
 919
 920           if(event_num > list_height - size){
 921             backward_num = event_num > RESERVE_SMALL_SIZE
 922               ? event_num - RESERVE_SMALL_SIZE : 1;
 923             ltt_event_position_set(&raw_data->ep, block_num, backward_num);
 924             ltt_tracefile_seek_position(tf, &raw_data->ep);
 925             ev = ltt_tracefile_read(tf);
 926             start = ltt_event_time(ev);
 927             maxNum = G_MAXULONG;
 928             event_viewer_data->current_event_index = 0;
 929             get_events(event_viewer_data, start, end, maxNum, &size);
 930             event_viewer_data->start_event_index = event_viewer_data->current_event_index;
 931           }
 932           event_number = event_viewer_data->raw_trace_data_queue->length - list_height;
 933         }else{
 934           event_number = 0;
 935         }
 936         break;
 937       case SCROLL_NONE:
 938         event_number = event_viewer_data->current_event_index;
 939         break;
 940       default:
 941           break;
 942     }
 943
 944     //update the value of the scroll bar
 945     if(direction != SCROLL_NONE && direction != SCROLL_JUMP){
 946       first = event_viewer_data->raw_trace_data_queue->head;
 947       raw_data = (RawTraceData*)g_list_nth_data(first,event_number);
 948       time = ltt_time_sub(raw_data->time, event_viewer_data->time_span.startTime);
 949       event_viewer_data->vadjust_c->value = ltt_time_to_double(time) * NANOSECONDS_PER_SECOND;
 950       g_signal_stop_emission_by_name(G_OBJECT(event_viewer_data->vadjust_c), "value-changed");
 951       event_viewer_data->previous_value = event_viewer_data->vadjust_c->value;
 952     }
 953
 954
 955     event_viewer_data->start_event_index = event_number;
 956     event_viewer_data->end_event_index = event_number + list_height - 1;
 957
 958     first = event_viewer_data->raw_trace_data_queue->head;
 959     gtk_list_store_clear(event_viewer_data->store_m);
 960     for(i=event_number; i<event_number+list_height; i++)
 961       {
 962         guint64 real_data;
 963
 964         if(i>=event_viewer_data->number_of_events) break;
 965
 966         raw_data = (RawTraceData*)g_list_nth_data(first, i);
 967
 968         // Add a new row to the model
 969         real_data = raw_data->time.tv_sec;
 970         real_data *= NANOSECONDS_PER_SECOND;
 971         real_data += raw_data->time.tv_nsec;
 972         gtk_list_store_append (event_viewer_data->store_m, &iter);
 973         gtk_list_store_set (event_viewer_data->store_m, &iter,
 974                             CPUID_COLUMN, raw_data->cpu_id,
 975                             EVENT_COLUMN, raw_data->event_name,
 976                             TIME_COLUMN, real_data,
 977                             PID_COLUMN, raw_data->pid,
 978                             ENTRY_LEN_COLUMN, raw_data->entry_length,
 979                             EVENT_DESCR_COLUMN, raw_data->event_description,
 980                             -1);
 981 /*
 982         gtk_list_store_append (event_viewer_data->store_m, &iter);
 983         gtk_list_store_set (event_viewer_data->store_m, &iter,
 984                             CPUID_COLUMN, 0,
 985                             EVENT_COLUMN, "event irq",
 986                             TIME_COLUMN, i,
 987                             PID_COLUMN, 100,
 988                             ENTRY_LEN_COLUMN, 17,
 989                             EVENT_DESCR_COLUMN, "Detailed information",
 990                             -1);
 991 */
 992       }
 993   }
 994 #ifdef DEBUG //do not use this, it's slower and broken
 995   //    } else {
 996   /* Some events will be reused */
 997   if(event_number < event_viewer_data->first_event)
 998     {
 999       /* scrolling up, prepend events */
1000       tree_path = gtk_tree_path_new_from_indices
1001         (event_number+list_height-1 -
1002          event_viewer_data->first_event + 1,
1003          -1);
1004       for(i=0; i<event_viewer_data->last_event-(event_number+list_height-1);
1005           i++)
1006         {
1007           /* Remove the last events from the list */
1008           if(gtk_tree_model_get_iter(model, &iter, tree_path))
1009             gtk_list_store_remove(event_viewer_data->store_m, &iter);
1010         }
1011
1012       for(i=event_viewer_data->first_event-1; i>=event_number; i--)
1013         {
1014           if(i>=event_viewer_data->number_of_events) break;
1015           /* Prepend new events */
1016           gtk_list_store_prepend (event_viewer_data->store_m, &iter);
1017           gtk_list_store_set (event_viewer_data->store_m, &iter,
1018                               CPUID_COLUMN, 0,
1019                               EVENT_COLUMN, "event irq",
1020                               TIME_COLUMN, i,
1021                               PID_COLUMN, 100,
1022                               ENTRY_LEN_COLUMN, 17,
1023                               EVENT_DESCR_COLUMN, "Detailed information",
1024                               -1);
1025         }
1026     } else {
1027       /* Scrolling down, append events */
1028       for(i=event_viewer_data->first_event; i<event_number; i++)
1029         {
1030           /* Remove these events from the list */
1031           gtk_tree_model_get_iter_first(model, &iter);
1032           gtk_list_store_remove(event_viewer_data->store_m, &iter);
1033         }
1034       for(i=event_viewer_data->last_event+1; i<event_number+list_height; i++)
1035         {
1036           if(i>=event_viewer_data->number_of_events) break;
1037           /* Append new events */
1038           gtk_list_store_append (event_viewer_data->store_m, &iter);
1039           gtk_list_store_set (event_viewer_data->store_m, &iter,
1040                               CPUID_COLUMN, 0,
1041                               EVENT_COLUMN, "event irq",
1042                               TIME_COLUMN, i,
1043                               PID_COLUMN, 100,
1044                               ENTRY_LEN_COLUMN, 17,
1045                               EVENT_DESCR_COLUMN, "Detailed information",
1046                               -1);
1047         }
1048
1049     }
1050   //}
1051 #endif //DEBUG
1052   event_viewer_data->first_event = event_viewer_data->start_event_index ;
1053   event_viewer_data->last_event = event_viewer_data->end_event_index ;
1054
1055
1056
1057 }
1058
1059
1060 void add_test_data(EventViewerData *event_viewer_data)
1061 {
1062   GtkTreeIter iter;
1063   int i;
1064
1065   for(i=0; i<10; i++)
1066     {
1067       /* Add a new row to the model */
1068       gtk_list_store_append (event_viewer_data->store_m, &iter);
1069       gtk_list_store_set (event_viewer_data->store_m, &iter,
1070                           CPUID_COLUMN, 0,
1071                           EVENT_COLUMN, "event irq",
1072                           TIME_COLUMN, i,
1073                           PID_COLUMN, 100,
1074                           ENTRY_LEN_COLUMN, 17,
1075                           EVENT_DESCR_COLUMN, "Detailed information",
1076                           -1);
1077     }
1078
1079 }
1080
1081 void
1082 gui_events_free(EventViewerData *event_viewer_data)
1083 {
1084   if(event_viewer_data){
1085     lttv_hooks_remove(event_viewer_data->before_event_hooks,parse_event);
1086     lttv_hooks_destroy(event_viewer_data->before_event_hooks);
1087
1088     remove_all_items_from_queue (event_viewer_data->raw_trace_data_queue);
1089     g_queue_free(event_viewer_data->raw_trace_data_queue);
1090     g_queue_free(event_viewer_data->raw_trace_data_queue_tmp);
1091
1092     unreg_update_time_window(update_time_window,event_viewer_data, event_viewer_data->mw);
1093     unreg_update_current_time(update_current_time,event_viewer_data, event_viewer_data->mw);
1094
1095     g_event_viewer_data_list = g_slist_remove(g_event_viewer_data_list, event_viewer_data);
1096     g_free(event_viewer_data);
1097   }
1098 }
1099
1100 void
1101 gui_events_destructor(EventViewerData *event_viewer_data)
1102 {
1103   guint index;
1104
1105   /* May already been done by GTK window closing */
1106   if(GTK_IS_WIDGET(event_viewer_data->hbox_v)){
1107     gtk_widget_destroy(event_viewer_data->hbox_v);
1108     event_viewer_data = NULL;
1109   }
1110
1111   /* Destroy the Tree View */
1112   //gtk_widget_destroy(event_viewer_data->tree_v);
1113
1114   /*  Clear raw event list */
1115   //gtk_list_store_clear(event_viewer_data->store_m);
1116   //gtk_widget_destroy(GTK_WIDGET(event_viewer_data->store_m));
1117
1118   //gui_events_free(event_viewer_data);
1119 }
1120
1121 //FIXME : call hGuiEvents_Destructor for corresponding data upon widget destroy
1122
1123 static void
1124 tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data)
1125 {
1126   EventViewerData *event_viewer_data = (EventViewerData*)data;
1127   GtkTreeIter iter;
1128   GtkTreeModel *model = GTK_TREE_MODEL(event_viewer_data->store_m);
1129   gchar *event;
1130
1131   if (gtk_tree_selection_get_selected (selection, &model, &iter))
1132     {
1133       gtk_tree_model_get (model, &iter, EVENT_COLUMN, &event, -1);
1134
1135       g_free (event);
1136     }
1137 }
1138
1139
1140 int event_selected_hook(void *hook_data, void *call_data)
1141 {
1142   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1143   guint *event_number = (guint*) call_data;
1144
1145   event_viewer_data->currently_selected_event = *event_number;
1146   event_viewer_data->selected_event = TRUE ;
1147
1148   tree_v_set_cursor(event_viewer_data);
1149
1150 }
1151
1152
1153 gboolean update_time_window(void * hook_data, void * call_data)
1154 {
1155   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1156   event_viewer_data->time_window = *(TimeWindow*)call_data;
1157
1158   return FALSE;
1159 }
1160
1161 gboolean update_current_time(void * hook_data, void * call_data)
1162 {
1163   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1164   event_viewer_data->current_time = *(LttTime*)call_data;
1165   uint64_t nsec = event_viewer_data->current_time.tv_sec * NANOSECONDS_PER_SECOND
1166                   + event_viewer_data->current_time.tv_nsec;
1167   GtkTreeIter iter;
1168   uint64_t time;
1169   int count = 0;
1170   GtkTreeModel* model = (GtkTreeModel*)event_viewer_data->store_m;
1171
1172
1173   if(gtk_tree_model_get_iter_first(model, &iter)){
1174     while(1){
1175       gtk_tree_model_get(model, &iter, TIME_COLUMN, &time, -1);
1176       if(time < nsec){
1177         if(!gtk_tree_model_iter_next(model, &iter)){
1178           return TRUE;
1179         }
1180         count++;
1181       }else{
1182         break;
1183       }
1184     }
1185     //    event_selected_hook(event_viewer_data, &count);
1186   }
1187
1188   return FALSE;
1189 }
1190
1191 void tree_v_grab_focus(GtkWidget *widget, gpointer data){
1192   EventViewerData *event_viewer_data = (EventViewerData *)data;
1193   MainWindow * mw = event_viewer_data->mw;
1194   set_focused_pane(mw, gtk_widget_get_parent(event_viewer_data->hbox_v));
1195 }
1196
1197 void get_events(EventViewerData* event_viewer_data, LttTime start,
1198                 LttTime end,unsigned max_num_events, unsigned * real_num_events)
1199 {
1200   int size;
1201   RawTraceData * data;
1202   context_add_hooks_api(event_viewer_data->mw, NULL, NULL, NULL, NULL, NULL, NULL,
1203                         NULL, NULL, NULL,event_viewer_data->before_event_hooks,NULL);
1204   process_traceset_api(event_viewer_data->mw, start, end, max_num_events);
1205   context_remove_hooks_api(event_viewer_data->mw, NULL, NULL, NULL, NULL, NULL, NULL,
1206                            NULL, NULL, NULL,event_viewer_data->before_event_hooks,NULL);
1207
1208   size = event_viewer_data->raw_trace_data_queue_tmp->length;
1209   *real_num_events = size;
1210   if(size > 0){
1211     int pid, tmpPid, i;
1212     GList * list, *tmpList;
1213
1214     //if the queue is full, remove some data, keep the size of the queue constant
1215     while(event_viewer_data->raw_trace_data_queue->length + size > RESERVE_BIG_SIZE){
1216       remove_item_from_queue(event_viewer_data->raw_trace_data_queue,
1217                              event_viewer_data->append);
1218     }
1219
1220     //update pid if it is not known
1221     if(event_viewer_data->raw_trace_data_queue->length > 0){
1222       list    = event_viewer_data->raw_trace_data_queue->head;
1223       tmpList = event_viewer_data->raw_trace_data_queue_tmp->head;
1224       if(event_viewer_data->append){
1225         data = (RawTraceData*)g_list_nth_data(list, event_viewer_data->raw_trace_data_queue->length-1);
1226         pid  = data->pid;
1227         data = (RawTraceData*)g_list_nth_data(tmpList, 0);
1228         tmpPid = data->pid;
1229       }else{
1230         data = (RawTraceData*)g_list_nth_data(list, 0);
1231         pid  = data->pid;
1232         data = (RawTraceData*)g_list_nth_data(tmpList, event_viewer_data->raw_trace_data_queue_tmp->length-1);
1233         tmpPid = data->pid;
1234       }
1235
1236       if(pid == -1 && tmpPid != -1){
1237         for(i=0;i<event_viewer_data->raw_trace_data_queue->length;i++){
1238           data = (RawTraceData*)g_list_nth_data(list,i);
1239           if(data->pid == -1) data->pid = tmpPid;
1240         }
1241       }else if(pid != -1 && tmpPid == -1){
1242         for(i=0;i<event_viewer_data->raw_trace_data_queue_tmp->length;i++){
1243           data = (RawTraceData*)g_list_nth_data(tmpList,i);
1244           if(data->pid == -1) data->pid = pid;
1245         }
1246       }
1247     }
1248
1249     //add data from tmp queue into the queue
1250     event_viewer_data->number_of_events = event_viewer_data->raw_trace_data_queue->length
1251                                         + event_viewer_data->raw_trace_data_queue_tmp->length;
1252     if(event_viewer_data->append){
1253       if(event_viewer_data->raw_trace_data_queue->length > 0)
1254         event_viewer_data->current_event_index = event_viewer_data->raw_trace_data_queue->length - 1;
1255       else event_viewer_data->current_event_index = 0;
1256       while((data = g_queue_pop_head(event_viewer_data->raw_trace_data_queue_tmp)) != NULL){
1257         g_queue_push_tail(event_viewer_data->raw_trace_data_queue, data);
1258       }
1259     }else{
1260       event_viewer_data->current_event_index += event_viewer_data->raw_trace_data_queue_tmp->length;
1261       while((data = g_queue_pop_tail(event_viewer_data->raw_trace_data_queue_tmp)) != NULL){
1262         g_queue_push_head(event_viewer_data->raw_trace_data_queue, data);
1263       }
1264     }
1265   }
1266 }
1267
1268 static void get_event_detail(LttEvent *e, LttField *f, GString * s)
1269 {
1270   LttType *type;
1271   LttField *element;
1272   char *name;
1273   int nb, i;
1274
1275   type = ltt_field_type(f);
1276   switch(ltt_type_class(type)) {
1277     case LTT_INT:
1278       g_string_append_printf(s, " %ld", ltt_event_get_long_int(e,f));
1279       break;
1280
1281     case LTT_UINT:
1282       g_string_append_printf(s, " %lu", ltt_event_get_long_unsigned(e,f));
1283       break;
1284
1285     case LTT_FLOAT:
1286       g_string_append_printf(s, " %g", ltt_event_get_double(e,f));
1287       break;
1288
1289     case LTT_STRING:
1290       g_string_append_printf(s, " \"%s\"", ltt_event_get_string(e,f));
1291       break;
1292
1293     case LTT_ENUM:
1294       g_string_append_printf(s, " %s", ltt_enum_string_get(type,
1295           ltt_event_get_unsigned(e,f)-1));
1296       break;
1297
1298     case LTT_ARRAY:
1299     case LTT_SEQUENCE:
1300       g_string_append_printf(s, " {");
1301       nb = ltt_event_field_element_number(e,f);
1302       element = ltt_field_element(f);
1303       for(i = 0 ; i < nb ; i++) {
1304         ltt_event_field_element_select(e,f,i);
1305         get_event_detail(e, element, s);
1306       }
1307       g_string_append_printf(s, " }");
1308       break;
1309
1310     case LTT_STRUCT:
1311       g_string_append_printf(s, " {");
1312       nb = ltt_type_member_number(type);
1313       for(i = 0 ; i < nb ; i++) {
1314         element = ltt_field_member(f,i);
1315         ltt_type_member_type(type, i, &name);
1316         g_string_append_printf(s, " %s = ", name);
1317         get_event_detail(e, element, s);
1318       }
1319       g_string_append_printf(s, " }");
1320       break;
1321   }
1322
1323 }
1324
1325 static void get_pid(unsigned * in, unsigned * out, char * s)
1326 {
1327   char * str;
1328   str = strstr(s, "out =");
1329   if (str){
1330     str = str + 5;
1331     sscanf(str,"%d", out);
1332   }else{
1333     g_warning("Can not find out pid\n");
1334   }
1335
1336   str = strstr(s,"in =");
1337   if (str){
1338     str = str + 4;
1339     sscanf(str,"%d", in);
1340   }else{
1341     g_warning("Can not find in pid\n");
1342   }
1343 }
1344
1345 gboolean parse_event(void *hook_data, void *call_data)
1346 {
1347   EventViewerData *event_viewer_data = (EventViewerData *)hook_data;
1348   LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1349   LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1350
1351   RawTraceData * tmp_raw_trace_data,*prev_raw_trace_data = NULL, *data=NULL;
1352   LttEvent *e;
1353   LttTime time;
1354   LttField * field;
1355   unsigned in=0, out=0;
1356   int i;
1357   GString * detail_event = g_string_new("");
1358   GList * list;
1359
1360   e = tfc->e;
1361   field = ltt_event_field(e);
1362   time = ltt_event_time(e);
1363
1364   if(event_viewer_data->raw_trace_data_queue_tmp->length){
1365     list = g_list_last(event_viewer_data->raw_trace_data_queue_tmp->head);
1366     prev_raw_trace_data = (RawTraceData *)(list->data);
1367   }
1368
1369   tmp_raw_trace_data = g_new(RawTraceData,1);
1370   tmp_raw_trace_data->cpu_id = ltt_event_cpu_id(e);
1371   tmp_raw_trace_data->event_name = g_strdup(ltt_eventtype_name(ltt_event_eventtype(e)));
1372   tmp_raw_trace_data->time = time;
1373
1374   if(prev_raw_trace_data) tmp_raw_trace_data->pid = prev_raw_trace_data->pid;
1375   else tmp_raw_trace_data->pid = -1;
1376
1377   tmp_raw_trace_data->entry_length = field == NULL ? 0 : field->field_size;
1378   if(field) get_event_detail(e, field, detail_event);
1379   tmp_raw_trace_data->event_description  = g_strdup(detail_event->str);
1380
1381   if(strcmp(tmp_raw_trace_data->event_name, "schedchange") == 0){
1382     get_pid(&in, &out, detail_event->str);
1383   }
1384
1385
1386   if(in != 0 || out != 0){
1387     tmp_raw_trace_data->pid = in;
1388     if(prev_raw_trace_data && prev_raw_trace_data->pid == -1){
1389       list = event_viewer_data->raw_trace_data_queue_tmp->head;
1390       for(i=0;i<event_viewer_data->raw_trace_data_queue_tmp->length;i++){
1391         data = (RawTraceData *)g_list_nth_data(list,i);
1392         data->pid = out;
1393       }
1394     }
1395   }
1396
1397   ltt_event_position(e, &tmp_raw_trace_data->ep);
1398
1399   if(event_viewer_data->raw_trace_data_queue_tmp->length >= RESERVE_SMALL_SIZE){
1400     if(event_viewer_data->append){
1401       list = g_list_last(event_viewer_data->raw_trace_data_queue_tmp->head);
1402       data = (RawTraceData *)(list->data);
1403       if(data->time.tv_sec  == time.tv_sec &&
1404          data->time.tv_nsec == time.tv_nsec){
1405         g_queue_push_tail(event_viewer_data->raw_trace_data_queue_tmp,tmp_raw_trace_data);
1406       }else{
1407         g_free(tmp_raw_trace_data);
1408       }
1409     }else{
1410       remove_item_from_queue(event_viewer_data->raw_trace_data_queue_tmp,TRUE);
1411       g_queue_push_tail(event_viewer_data->raw_trace_data_queue_tmp,tmp_raw_trace_data);
1412     }
1413   }else{
1414     g_queue_push_tail (event_viewer_data->raw_trace_data_queue_tmp,tmp_raw_trace_data);
1415   }
1416
1417   g_string_free(detail_event, TRUE);
1418
1419   return FALSE;
1420 }
1421
1422 void remove_item_from_queue(GQueue * q, gboolean fromHead)
1423 {
1424   RawTraceData *data1, *data2 = NULL;
1425   GList * list;
1426
1427   if(fromHead){
1428     data1 = (RawTraceData *)g_queue_pop_head(q);
1429     list  = g_list_first(q->head);
1430     if(list)
1431       data2 = (RawTraceData *)(list->data);
1432   }else{
1433     data1 = (RawTraceData *)g_queue_pop_tail(q);
1434     list  = g_list_last(q->head);
1435     if(list)
1436       data2 = (RawTraceData *)(list->data);
1437   }
1438
1439   if(data2){
1440     if(data1->time.tv_sec  == data2->time.tv_sec &&
1441        data1->time.tv_nsec == data2->time.tv_nsec){
1442       remove_item_from_queue(q, fromHead);
1443     }
1444   }
1445
1446   g_free(data1);
1447
1448   return;
1449 }
1450
1451 void remove_all_items_from_queue(GQueue *q)
1452 {
1453   RawTraceData *data;
1454   while((data = (RawTraceData *)g_queue_pop_head(q)) != NULL){
1455     g_free(data);
1456   }
1457 }
1458
1459