lttv/modules/gui/detailedevents/events.c

   1 /* This file is part of the Linux Trace Toolkit viewer
   2  * Copyright (C) 2003-2004 Mathieu Desnoyers and XangXiu Yang
   3  *               2005 Mathieu Desnoyers
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License Version 2 as
   7  * published by the Free Software Foundation;
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  17  * MA 02111-1307, USA.
  18  */
  19
  20
  21 //*! \defgroup GuiEvents libGuiEvents: The GUI Events display plugin */
  22 /*\@{*/
  23
  24 /*! \file GuiEvents.c
  25  * \brief Graphical plugin for showing events.
  26  *
  27  * This plugin lists all the events contained in the current time interval
  28  * in a list.
  29  *
  30  * This plugin adds a Events Viewer functionnality to Linux TraceToolkit
  31  * GUI when this plugin is loaded. The init and destroy functions add the
  32  * viewer's insertion menu item and toolbar icon by calling viewer.h's
  33  * API functions. Then, when a viewer's object is created, the constructor
  34  * creates ans register through API functions what is needed to interact
  35  * with the lttvwindow.
  36  *
  37  * Authors : Mathieu Desnoyers and XangXiu Yang, June to December 2003
  38  *           Inspired from original LTT, made by Karim Yaghmour
  39  *
  40  *           Mostly rewritten by Mathieu Desnoyers, August 2005.
  41  */
  42
  43 #ifdef HAVE_CONFIG_H
  44 #include <config.h>
  45 #endif
  46
  47 #include <math.h>
  48
  49 #include <glib.h>
  50 #include <glib/gprintf.h>
  51 #include <gtk/gtk.h>
  52 #include <gdk/gdk.h>
  53 #include <gdk/gdkx.h>
  54 #include <string.h>
  55
  56 #include <lttv/lttv.h>
  57 #include <lttv/module.h>
  58 #include <lttv/hook.h>
  59 #include <lttv/traceset.h>
  60 #include <lttv/state.h>
  61 #ifdef BABEL_CLEANUP
  62 #include <lttv/filter.h>
  63 #endif //babel_cleanup
  64 #include <lttv/print.h>
  65 #include <lttvwindow/lttvwindow.h>
  66 #include <lttvwindow/lttvwindowtraces.h>
  67 #include <lttvwindow/lttv_plugin_tab.h>
  68 #include <lttvwindow/support.h>
  69 #include "lttv_plugin_evd.h"
  70
  71 #include "events.h"
  72 #include "hGuiEventsInsert.xpm"
  73
  74 #define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format)
  75
  76 #ifndef g_debug
  77 #define g_debug(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format)
  78 #endif
  79
  80 #define abs(a) (((a)<0)?(-a):(a))
  81 #define max(a,b) ((a)>(b)?(a):(b))
  82 #define min(a,b) ((a)<(b)?(a):(b))
  83
  84 /** Array containing instanced objects. Used when module is unloaded */
  85 static GSList *g_event_viewer_data_list = NULL ;
  86
  87 typedef enum _ScrollDirection{
  88   SCROLL_STEP_UP,
  89   SCROLL_STEP_DOWN,
  90   SCROLL_PAGE_UP,
  91   SCROLL_PAGE_DOWN,
  92   SCROLL_JUMP,
  93   SCROLL_NONE
  94 } ScrollDirection;
  95
  96 /** hook functions for update time interval, current time ... */
  97 gboolean update_current_time(void * hook_data, void * call_data);
  98 gboolean update_current_position(void * hook_data, void * call_data);
  99 //gboolean show_event_detail(void * hook_data, void * call_data);
 100 gboolean traceset_changed(void * hook_data, void * call_data);
 101 gboolean timespan_changed(void * hook_data, void * call_data);
 102 #ifdef BABEL_CLEANUP
 103 gboolean filter_changed(void * hook_data, void * call_data);
 104 #endif // babel_cleanup
 105 static void request_background_data(EventViewerData *event_viewer_data);
 106
 107 //! Event Viewer's constructor hook
 108 GtkWidget *h_gui_events(LttvPlugin *plugin);
 109 //! Event Viewer's constructor
 110 EventViewerData *gui_events(LttvPluginTab *ptab);
 111 //! Event Viewer's destructor
 112 void gui_events_destructor(gpointer data);
 113 void gui_events_free(gpointer data);
 114
 115 static gboolean
 116 header_size_allocate(GtkWidget *widget,
 117                         GtkAllocation *allocation,
 118                         gpointer user_data);
 119
 120 void tree_v_set_cursor(EventViewerData *event_viewer_data);
 121 void tree_v_get_cursor(EventViewerData *event_viewer_data);
 122 static void redraw(EventViewerData *event_viewer_data);
 123
 124 /* Prototype for selection handler callback */
 125 static void tree_selection_changed_cb (GtkTreeSelection *selection,
 126     gpointer data);
 127 static void v_scroll_cb (GtkAdjustment *adjustment, gpointer data);
 128 static void tree_v_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc,
 129     gpointer data);
 130 static void tree_v_size_request_cb (GtkWidget *widget,
 131     GtkRequisition *requisition, gpointer data);
 132 static void tree_v_cursor_changed_cb (GtkWidget *widget, gpointer data);
 133 static void tree_v_move_cursor_cb (GtkWidget *widget, GtkMovementStep arg1,
 134     gint arg2, gpointer data);
 135 static void        filter_button      (GtkToolButton *toolbutton,
 136                                           gpointer       user_data);
 137 static gboolean tree_v_scroll_handler (GtkWidget *widget, GdkEventScroll *event, gpointer data);
 138 static gboolean key_handler(GtkWidget *widget, GdkEventKey *event,
 139     gpointer user_data);
 140
 141 static void adjust_event_viewer(double time, EventViewerData *event_viewer_data);
 142
 143 int event_hook(void *hook_data, void *call_data);
 144
 145 /* Enumeration of the columns */
 146 enum
 147 {
 148   TRACE_NAME_COLUMN,
 149   CPUID_COLUMN,
 150   EVENT_COLUMN,
 151   TIME_S_COLUMN,
 152   TIME_NS_COLUMN,
 153   PID_COLUMN,
 154   EVENT_DESCR_COLUMN,
 155   POSITION_COLUMN,
 156   N_COLUMNS
 157 };
 158
 159 /**
 160  * Event Viewer's constructor hook
 161  *
 162  * This constructor is given as a parameter to the menuitem and toolbar button
 163  * registration. It creates the list.
 164  * @param parent_window A pointer to the parent window.
 165  * @return The widget created.
 166  */
 167 GtkWidget *
 168 h_gui_events(LttvPlugin *plugin)
 169 {
 170   LttvPluginTab *ptab = LTTV_PLUGIN_TAB(plugin);
 171   EventViewerData* event_viewer_data = gui_events(ptab) ;
 172   if(event_viewer_data)
 173     return event_viewer_data->top_widget;
 174   else return NULL;
 175
 176 }
 177
 178 /**
 179  * Event Viewer's constructor
 180  *
 181  * This constructor is used to create EventViewerData data structure.
 182  * @return The Event viewer data created.
 183  */
 184 EventViewerData *
 185 gui_events(LttvPluginTab *ptab)
 186 {
 187   /*To disable the error bell when we reach the end(or the top) of the list of
 188          event. Since we overload the management of the list*/
 189   GtkSettings* gtk_settings = gtk_settings_get_default();
 190   g_object_set(gtk_settings, "gtk-error-bell", FALSE, NULL);
 191
 192
 193   LttTime end;
 194   GtkTreeViewColumn *column;
 195   GtkCellRenderer *renderer;
 196   EventViewerData* event_viewer_data = g_new(EventViewerData,1);
 197   LttvPluginEVD *plugin_evd = g_object_new(LTTV_TYPE_PLUGIN_EVD, NULL);
 198   GtkTooltips *tooltips = gtk_tooltips_new();
 199   plugin_evd->evd = event_viewer_data;
 200   Tab *tab = ptab->tab;
 201   event_viewer_data->tab = tab;
 202   event_viewer_data->ptab = ptab;
 203   GtkWidget *tmp_toolbar_icon;
 204
 205   LttvTraceset *ts =lttvwindow_get_traceset(event_viewer_data->tab);
 206
 207   event_viewer_data->event_hooks = lttv_hooks_new();
 208   lttv_hooks_add(event_viewer_data->event_hooks,
 209                  event_hook,
 210                  event_viewer_data,
 211                  LTTV_PRIO_DEFAULT);
 212
 213   lttvwindow_register_current_time_notify(tab,
 214                 update_current_time,event_viewer_data);
 215   lttvwindow_register_current_position_notify(tab,
 216                 update_current_position,event_viewer_data);
 217   lttvwindow_register_traceset_notify(tab,
 218                 traceset_changed,event_viewer_data);
 219   lttvwindow_register_timespan_notify(tab,
 220                 timespan_changed,event_viewer_data);
 221 #ifdef BABEL_CLEANUP
 222   lttvwindow_register_filter_notify(tab,
 223                 filter_changed, event_viewer_data);
 224 #endif
 225   lttvwindow_register_redraw_notify(tab,
 226                 evd_redraw_notify, event_viewer_data);
 227   event_viewer_data->scroll_win = gtk_scrolled_window_new (NULL, NULL);
 228   gtk_widget_show (event_viewer_data->scroll_win);
 229   gtk_scrolled_window_set_policy(
 230       GTK_SCROLLED_WINDOW(event_viewer_data->scroll_win),
 231       GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
 232
 233   event_viewer_data->currently_selected_position =
 234                                 lttv_traceset_create_current_position(ts);
 235   event_viewer_data->first_event =
 236                                 lttv_traceset_create_current_position(ts);
 237   event_viewer_data->last_event =
 238                                 lttv_traceset_create_current_position(ts);
 239   event_viewer_data->main_win_filter = lttvwindow_get_filter(tab);
 240
 241   event_viewer_data->update_cursor = TRUE;
 242   event_viewer_data->report_position = TRUE;
 243
 244   event_viewer_data->last_tree_update_time = 0;
 245
 246   event_viewer_data->init_done = 0;
 247
 248   /* Create a model for storing the data list */
 249   event_viewer_data->store_m = gtk_list_store_new (
 250     N_COLUMNS,      /* Total number of columns     */
 251     G_TYPE_STRING,  /* Trace name                  */
 252     G_TYPE_UINT,    /* CPUID                       */
 253     G_TYPE_STRING,  /* Event                       */
 254     G_TYPE_UINT,    /* Time s                      */
 255     G_TYPE_UINT,    /* Time ns                     */
 256     G_TYPE_INT,     /* PID                         */
 257     G_TYPE_STRING,  /* Event's description         */
 258     G_TYPE_POINTER);/* Position (not shown)        */
 259
 260   event_viewer_data->pos = g_ptr_array_sized_new(10);
 261
 262   /* Create the viewer widget for the columned list */
 263   event_viewer_data->tree_v =
 264     gtk_tree_view_new_with_model (GTK_TREE_MODEL (event_viewer_data->store_m));
 265
 266   g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "size-allocate",
 267         G_CALLBACK (tree_v_size_allocate_cb),
 268         event_viewer_data);
 269   g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "size-request",
 270         G_CALLBACK (tree_v_size_request_cb),
 271         event_viewer_data);
 272
 273   g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "cursor-changed",
 274         G_CALLBACK (tree_v_cursor_changed_cb),
 275         event_viewer_data);
 276
 277   g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "move-cursor",
 278         G_CALLBACK (tree_v_move_cursor_cb),
 279         event_viewer_data);
 280
 281   g_signal_connect (G_OBJECT(event_viewer_data->tree_v), "key-press-event",
 282       G_CALLBACK(key_handler),
 283       event_viewer_data);
 284
 285   g_signal_connect (G_OBJECT(event_viewer_data->tree_v), "scroll-event",
 286       G_CALLBACK(tree_v_scroll_handler),
 287       event_viewer_data);
 288
 289
 290
 291   // Use on each column!
 292   //gtk_tree_view_column_set_sizing(event_viewer_data->tree_v,
 293   //GTK_TREE_VIEW_COLUMN_FIXED);
 294
 295   /* The view now holds a reference.  We can get rid of our own
 296    * reference */
 297   g_object_unref (G_OBJECT (event_viewer_data->store_m));
 298
 299
 300   /* Create a column, associating the "text" attribute of the
 301    * cell_renderer to the first column of the model */
 302   /* Columns alignment : 0.0 : Left    0.5 : Center   1.0 : Right */
 303   renderer = gtk_cell_renderer_text_new ();
 304   column = gtk_tree_view_column_new_with_attributes ("Trace",
 305                  renderer,
 306                  "text", TRACE_NAME_COLUMN,
 307                  NULL);
 308   gtk_tree_view_column_set_alignment (column, 0.0);
 309   gtk_tree_view_column_set_fixed_width (column, 120);
 310   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 311       column);
 312
 313   event_viewer_data->button = column->button;
 314
 315   g_signal_connect (G_OBJECT(event_viewer_data->button),
 316         "size-allocate",
 317         G_CALLBACK(header_size_allocate),
 318         (gpointer)event_viewer_data);
 319
 320   renderer = gtk_cell_renderer_text_new ();
 321   column = gtk_tree_view_column_new_with_attributes ("CPUID",
 322                  renderer,
 323                  "text", CPUID_COLUMN,
 324                  NULL);
 325   gtk_tree_view_column_set_alignment (column, 0.0);
 326   gtk_tree_view_column_set_fixed_width (column, 45);
 327   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 328       column);
 329
 330   renderer = gtk_cell_renderer_text_new ();
 331   column = gtk_tree_view_column_new_with_attributes ("Event",
 332                  renderer,
 333                  "text", EVENT_COLUMN,
 334                  NULL);
 335   gtk_tree_view_column_set_alignment (column, 0.0);
 336   gtk_tree_view_column_set_fixed_width (column, 120);
 337   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 338       column);
 339
 340   renderer = gtk_cell_renderer_text_new ();
 341   column = gtk_tree_view_column_new_with_attributes ("Time (s)",
 342                  renderer,
 343                  "text", TIME_S_COLUMN,
 344                  NULL);
 345   gtk_tree_view_column_set_alignment (column, 1.0);
 346   gtk_tree_view_column_set_fixed_width (column, 120);
 347   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 348       column);
 349
 350   renderer = gtk_cell_renderer_text_new ();
 351   column = gtk_tree_view_column_new_with_attributes ("Time (ns)",
 352                  renderer,
 353                  "text", TIME_NS_COLUMN,
 354                  NULL);
 355   gtk_tree_view_column_set_alignment (column, 1.0);
 356   gtk_tree_view_column_set_fixed_width (column, 120);
 357   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 358       column);
 359
 360
 361   renderer = gtk_cell_renderer_text_new ();
 362   column = gtk_tree_view_column_new_with_attributes ("PID",
 363                  renderer,
 364                  "text", PID_COLUMN,
 365                  NULL);
 366   gtk_tree_view_column_set_alignment (column, 1.0);
 367   gtk_tree_view_column_set_fixed_width (column, 45);
 368   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 369       column);
 370
 371   renderer = gtk_cell_renderer_text_new ();
 372   column = gtk_tree_view_column_new_with_attributes ("Event Description",
 373                  renderer,
 374                  "text", EVENT_DESCR_COLUMN,
 375                  NULL);
 376   gtk_tree_view_column_set_alignment (column, 0.0);
 377   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 378       column);
 379
 380
 381   /* Setup the selection handler */
 382   event_viewer_data->select_c =
 383     gtk_tree_view_get_selection (GTK_TREE_VIEW (event_viewer_data->tree_v));
 384   gtk_tree_selection_set_mode (event_viewer_data->select_c,
 385       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),
 391       event_viewer_data->tree_v);
 392
 393   event_viewer_data->hbox_v = gtk_hbox_new(0, 0);
 394   event_viewer_data->top_widget = event_viewer_data->hbox_v;
 395   plugin_evd->parent.top_widget = event_viewer_data->hbox_v;
 396
 397   event_viewer_data->toolbar = gtk_toolbar_new();
 398   gtk_toolbar_set_orientation(GTK_TOOLBAR(event_viewer_data->toolbar),
 399                               GTK_ORIENTATION_VERTICAL);
 400
 401   tmp_toolbar_icon = create_pixmap (main_window_get_widget(tab),
 402       "guifilter16x16.png");
 403   gtk_widget_show(tmp_toolbar_icon);
 404   event_viewer_data->button_filter = gtk_tool_button_new(tmp_toolbar_icon,
 405       "Filter");
 406   g_signal_connect (G_OBJECT(event_viewer_data->button_filter),
 407         "clicked",
 408         G_CALLBACK (filter_button),
 409         (gpointer)plugin_evd);
 410   gtk_tool_item_set_tooltip(GTK_TOOL_ITEM(event_viewer_data->button_filter),
 411       tooltips, "Open the filter window", NULL);
 412   gtk_toolbar_insert(GTK_TOOLBAR(event_viewer_data->toolbar),
 413       event_viewer_data->button_filter,
 414       0);
 415   gtk_toolbar_set_style(GTK_TOOLBAR(event_viewer_data->toolbar),
 416       GTK_TOOLBAR_ICONS);
 417   gtk_box_pack_start(GTK_BOX(event_viewer_data->hbox_v),
 418       event_viewer_data->toolbar, FALSE, FALSE, 0);
 419   event_viewer_data->filter = NULL;
 420
 421   gtk_box_pack_start(GTK_BOX(event_viewer_data->hbox_v),
 422       event_viewer_data->scroll_win, TRUE, TRUE, 0);
 423
 424   gtk_container_set_border_width(GTK_CONTAINER(event_viewer_data->hbox_v), 1);
 425
 426   /* Create vertical scrollbar and pack it */
 427   event_viewer_data->vscroll_vc = gtk_vscrollbar_new(NULL);
 428   gtk_range_set_update_policy (GTK_RANGE(event_viewer_data->vscroll_vc),
 429              GTK_UPDATE_CONTINUOUS);
 430              // Changed by MD : more user friendly :)
 431              //GTK_UPDATE_DISCONTINUOUS);
 432   gtk_box_pack_start(GTK_BOX(event_viewer_data->hbox_v),
 433       event_viewer_data->vscroll_vc, FALSE, TRUE, 0);
 434
 435   /* Get the vertical scrollbar's adjustment */
 436   event_viewer_data->vadjust_c =
 437     gtk_range_get_adjustment(GTK_RANGE(event_viewer_data->vscroll_vc));
 438   event_viewer_data->vtree_adjust_c = gtk_tree_view_get_vadjustment(
 439                     GTK_TREE_VIEW (event_viewer_data->tree_v));
 440
 441   g_signal_connect (G_OBJECT (event_viewer_data->vadjust_c), "value-changed",
 442         G_CALLBACK (v_scroll_cb),
 443         event_viewer_data);
 444   //TODO ybrosseau 2011-01-06: Fix comment
 445   /* Set the upper bound to the last event number */
 446   event_viewer_data->previous_value = 0;
 447   event_viewer_data->vadjust_c->lower = 0.0;
 448     //event_viewer_data->vadjust_c->upper = event_viewer_data->number_of_events;
 449
 450   LttTime time = lttvwindow_get_current_time(tab);
 451   TimeInterval time_span = lttv_traceset_get_time_span_real(ts);
 452   time = ltt_time_sub(time, time_span.start_time);
 453   //TODO ybrosseau 2011-01-06: Which one do we keep?
 454 #ifdef BABEL_CLEANUP
 455   event_viewer_data->vadjust_c->value = ltt_time_to_double(time);
 456 #endif //babel_cleanup
 457   event_viewer_data->vadjust_c->value = 0.0;
 458   event_viewer_data->vadjust_c->step_increment = 1.0;
 459   event_viewer_data->vadjust_c->page_increment = 2.0;
 460     //  event_viewer_data->vtree_adjust_c->upper;
 461   event_viewer_data->vadjust_c->page_size = 2.0;
 462   //    event_viewer_data->vtree_adjust_c->upper;
 463   /*  Raw event trace */
 464   gtk_widget_show(GTK_WIDGET(event_viewer_data->button_filter));
 465   gtk_widget_show(event_viewer_data->toolbar);
 466   gtk_widget_show(event_viewer_data->hbox_v);
 467   gtk_widget_show(event_viewer_data->tree_v);
 468   gtk_widget_show(event_viewer_data->vscroll_vc);
 469
 470   /* Add the object's information to the module's array */
 471   g_event_viewer_data_list = g_slist_append(g_event_viewer_data_list,
 472       plugin_evd);
 473
 474   event_viewer_data->num_visible_events = 1;
 475
 476   //get the life span of the traceset and set the upper of the scroll bar
 477
 478   end = ltt_time_sub(time_span.end_time, time_span.start_time);
 479
 480   event_viewer_data->vadjust_c->upper = ltt_time_to_double(end);
 481
 482   /* Set the Selected Event */
 483   //  tree_v_set_cursor(event_viewer_data);
 484
 485  // event_viewer_data->current_time_updated = FALSE;
 486  //
 487   g_object_set_data_full(
 488       G_OBJECT(event_viewer_data->hbox_v),
 489       "plugin_data",
 490       plugin_evd,
 491       (GDestroyNotify)gui_events_free);
 492
 493   g_object_set_data(
 494       G_OBJECT(event_viewer_data->hbox_v),
 495       "event_viewer_data",
 496       event_viewer_data);
 497
 498   event_viewer_data->background_info_waiting = 0;
 499
 500
 501   request_background_data(event_viewer_data);
 502   return event_viewer_data;
 503 }
 504
 505
 506
 507 static gint background_ready(void *hook_data, void *call_data)
 508 {
 509   EventViewerData *event_viewer_data = (EventViewerData *)hook_data;
 510
 511   event_viewer_data->background_info_waiting--;
 512
 513   if(event_viewer_data->background_info_waiting == 0) {
 514     g_message("event viewer : background computation data ready.");
 515
 516     evd_redraw_notify(event_viewer_data, NULL);
 517   }
 518
 519   return 0;
 520 }
 521
 522
 523 static void request_background_data(EventViewerData *event_viewer_data)
 524 {
 525   LttvTraceset * ts =
 526         lttvwindow_get_traceset(event_viewer_data->tab);
 527   gint num_traces = ts->traces->len;
 528   gint i;
 529   LttvTrace *trace;
 530   LttvTraceState *tstate;
 531
 532   LttvHooks *background_ready_hook =
 533     lttv_hooks_new();
 534   lttv_hooks_add(background_ready_hook, background_ready, event_viewer_data,
 535       LTTV_PRIO_DEFAULT);
 536   event_viewer_data->background_info_waiting = 0;
 537
 538   for(i=0;i<num_traces;i++) {
 539     trace = g_ptr_array_index(ts->traces,i);
 540 #ifdef BABEL_CLEANUP
 541     tstate = LTTV_TRACE_STATE(tsc->traces[i]);
 542 #endif /*babel_cleanup*/
 543
 544     if(lttvwindowtraces_get_ready(g_quark_from_string("state"),trace)==FALSE
 545         /*&& !tstate->has_precomputed_states*/) {
 546
 547       if(lttvwindowtraces_get_in_progress(g_quark_from_string("state"),
 548                                           trace) == FALSE) {
 549         /* We first remove requests that could have been done for the same
 550          * information. Happens when two viewers ask for it before servicing
 551          * starts.
 552          */
 553         if(!lttvwindowtraces_background_request_find(trace, "state"))
 554           lttvwindowtraces_background_request_queue(
 555               main_window_get_widget(event_viewer_data->tab), trace, "state");
 556         lttvwindowtraces_background_notify_queue(event_viewer_data,
 557                                                  trace,
 558                                                  ltt_time_infinite,
 559                                                  NULL,
 560                                                  background_ready_hook);
 561         event_viewer_data->background_info_waiting++;
 562       } else { /* in progress */
 563
 564         lttvwindowtraces_background_notify_current(event_viewer_data,
 565                                                    trace,
 566                                                    ltt_time_infinite,
 567                                                    NULL,
 568                                                    background_ready_hook);
 569         event_viewer_data->background_info_waiting++;
 570       }
 571     } else {
 572       /* Data ready. By its nature, this viewer doesn't need to have
 573        * its data ready hook called there, because a background
 574        * request is always linked with a redraw.
 575        */
 576     }
 577
 578   }
 579
 580   lttv_hooks_destroy(background_ready_hook);
 581 }
 582
 583 static gboolean
 584 header_size_allocate(GtkWidget *widget,
 585                         GtkAllocation *allocation,
 586                         gpointer user_data)
 587 {
 588   EventViewerData *event_viewer_data = (EventViewerData*)user_data;
 589
 590   event_viewer_data->header_height = allocation->height;
 591
 592   return 0;
 593 }
 594
 595
 596 void tree_v_set_cursor(EventViewerData *event_viewer_data)
 597 {
 598   g_debug("set cursor cb - do nothing");
 599
 600 }
 601
 602 void tree_v_get_cursor(EventViewerData *event_viewer_data)
 603 {
 604   g_debug("get cursor cb -  do nothing");
 605
 606
 607 }
 608
 609 /* Filter out the key repeats that come too fast */
 610 static gboolean key_handler(GtkWidget *widget, GdkEventKey *event,
 611     gpointer user_data)
 612 {
 613   EventViewerData *evd = (EventViewerData *)user_data;
 614
 615   g_debug("event time : %u , last time : %u", event->time,
 616       evd->last_tree_update_time);
 617
 618   if(guint32_before(event->time, evd->last_tree_update_time))
 619     return TRUE;
 620   else
 621     return FALSE;
 622 }
 623
 624 void tree_v_move_cursor_cb (GtkWidget *widget,
 625                             GtkMovementStep stepType,
 626                             gint arg2,
 627                             gpointer data)
 628 {
 629
 630   GtkTreePath *path; // = gtk_tree_path_new();
 631   EventViewerData *event_viewer_data = (EventViewerData*)data;
 632
 633   g_debug("move cursor cb");
 634   //gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 635   //                          &path, NULL);
 636   //if(path == NULL)
 637   //{
 638     /* No prior cursor, put it at beginning of page
 639      * and let the execution do */
 640   //  path = gtk_tree_path_new_from_indices(0, -1);
 641   //  gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 642   //                              path, NULL, FALSE);
 643   //}
 644
 645   //indices = gtk_tree_path_get_indices(path);
 646
 647   //value = gtk_adjustment_get_value(event_viewer_data->vadjust_c);
 648
 649   /* If events request pending, do nothing*/
 650   if(lttvwindow_events_request_pending(event_viewer_data->tab)) return;
 651
 652   /* If no prior position... */
 653
 654
 655   g_debug("tree view move cursor : stepType is %u and arg2 is %d",
 656       (guint)stepType, arg2);
 657
 658   switch(stepType) {
 659   case GTK_MOVEMENT_DISPLAY_LINES:
 660     if(arg2 == 1) {
 661       /* Move one line down */
 662       LttvTracesetPosition *end_pos = 0;
 663       if(event_viewer_data->pos->len > 0) {
 664         end_pos =
 665           (LttvTracesetPosition*)g_ptr_array_index(
 666                                              event_viewer_data->pos,
 667                                              event_viewer_data->pos->len-1);
 668       }
 669       if(!end_pos || lttv_traceset_position_compare(end_pos,
 670               event_viewer_data->currently_selected_position) == 0) {
 671           /* Must get down one event and select the last one */
 672           gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
 673                 GTK_TREE_VIEW(event_viewer_data->tree_v)));
 674                                         event_viewer_data->update_cursor = FALSE;
 675                                         gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 676                                                         gtk_adjustment_get_value(event_viewer_data->vadjust_c) + 1);
 677                                         event_viewer_data->update_cursor = TRUE;
 678                                         if(event_viewer_data->pos->len > 0) {
 679                                                 path = gtk_tree_path_new_from_indices(
 680                                                                 max(0, event_viewer_data->pos->len - 1), -1);
 681                                                 if(path) {
 682                                                         gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 683                                                                                          path, NULL, FALSE);
 684                                                         gtk_tree_path_free(path);
 685                                                 }
 686                                         }
 687                                 }
 688
 689     } else {
 690       LttvTracesetPosition *begin_pos = 0;
 691
 692       if(event_viewer_data->pos->len > 0) {
 693         /* Move one line up */
 694         begin_pos =
 695           (LttvTracesetPosition*)g_ptr_array_index(
 696             event_viewer_data->pos,
 697             0);
 698       }
 699       if(!begin_pos || lttv_traceset_position_compare(begin_pos,
 700               event_viewer_data->currently_selected_position) == 0)
 701
 702
 703       {
 704         /* Must get up one event and select the first one */
 705         gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
 706                                           GTK_TREE_VIEW(event_viewer_data->tree_v)));
 707         event_viewer_data->update_cursor = FALSE;
 708         gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 709                                 gtk_adjustment_get_value(event_viewer_data->vadjust_c) - 1);
 710         event_viewer_data->update_cursor = TRUE;
 711         if(event_viewer_data->pos->len > 0) {
 712           path = gtk_tree_path_new_from_indices(
 713             0, -1);
 714           if(path) {
 715             gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 716                                     path, NULL, FALSE);
 717             gtk_tree_path_free(path);
 718           }
 719         }
 720       }
 721
 722     }
 723     break;
 724   case GTK_MOVEMENT_PAGES:
 725     if(arg2 == 1) {
 726       /* Move one page down */
 727       LttvTracesetPosition *end_pos = 0;
 728       if(event_viewer_data->pos->len > 0) {
 729         end_pos =
 730           (LttvTracesetPosition*)g_ptr_array_index(
 731                                              event_viewer_data->pos,
 732                                              event_viewer_data->pos->len-1);
 733       }
 734         if(!end_pos || lttv_traceset_position_compare(end_pos,
 735               event_viewer_data->currently_selected_position) == 0) {
 736           /* Must get down one page and select the last one */
 737           gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
 738                 GTK_TREE_VIEW(event_viewer_data->tree_v)));
 739                                         event_viewer_data->update_cursor = FALSE;
 740                                         gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 741                                                         gtk_adjustment_get_value(event_viewer_data->vadjust_c) + 2);
 742                                         event_viewer_data->update_cursor = TRUE;
 743                                         if(event_viewer_data->pos->len > 0) {
 744                                                 path = gtk_tree_path_new_from_indices(
 745                                                                 event_viewer_data->pos->len - 1, -1);
 746                                                 if(path) {
 747                                                         gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 748                                                                                                                                                          path, NULL, FALSE);
 749                                                         gtk_tree_path_free(path);
 750                                                 }
 751                                         }
 752                                 }
 753     } else {
 754       /* Move one page up */
 755       LttvTracesetPosition *begin_pos = 0;
 756
 757       if(event_viewer_data->pos->len > 0) {
 758         begin_pos =
 759           (LttvTracesetPosition*)g_ptr_array_index(
 760                                              event_viewer_data->pos,
 761                                              0);
 762       }
 763         if(!begin_pos || lttv_traceset_position_compare(begin_pos,
 764               event_viewer_data->currently_selected_position) == 0) {
 765           /* Must get up one page and select the first one */
 766           gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
 767                 GTK_TREE_VIEW(event_viewer_data->tree_v)));
 768                                         event_viewer_data->update_cursor = FALSE;
 769                                         gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 770                                                         gtk_adjustment_get_value(event_viewer_data->vadjust_c) - 2);
 771                                         event_viewer_data->update_cursor = TRUE;
 772                                         if(event_viewer_data->pos->len > 0) {
 773                                                 path = gtk_tree_path_new_from_indices(
 774                                                                 0, -1);
 775                                                 if(path) {
 776                                                         gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 777                                                                                                                                                          path, NULL, FALSE);
 778                                                         gtk_tree_path_free(path);
 779                                                 }
 780                                         }
 781                                 }
 782     }
 783     break;
 784   default:
 785     break;
 786   }
 787   //gtk_tree_path_free(path);
 788
 789 }
 790
 791 static void        filter_button      (GtkToolButton *toolbutton,
 792                                           gpointer       user_data)
 793 {
 794   LttvPluginEVD *plugin_evd = (LttvPluginEVD*)user_data;
 795   LttvAttribute *attribute;
 796   LttvAttributeValue value;
 797   gboolean ret;
 798   g_printf("Filter button clicked\n");
 799
 800   attribute = LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
 801         LTTV_IATTRIBUTE(lttv_global_attributes()),
 802         LTTV_VIEWER_CONSTRUCTORS));
 803   g_assert(attribute);
 804
 805   ret = lttv_iattribute_find_by_path(LTTV_IATTRIBUTE(attribute),
 806       "guifilter", LTTV_POINTER, &value);
 807   g_assert(ret);
 808   lttvwindow_viewer_constructor constructor =
 809     (lttvwindow_viewer_constructor)*(value.v_pointer);
 810   if(constructor) constructor(&plugin_evd->parent);
 811   else g_warning("Filter module not loaded.");
 812
 813   //FIXME : viewer returned.
 814 }
 815
 816 gboolean tree_v_scroll_handler (GtkWidget *widget, GdkEventScroll *event, gpointer data)
 817 {
 818         EventViewerData *event_viewer_data = (EventViewerData*) data;
 819
 820         switch(event->direction) {
 821                 case GDK_SCROLL_UP:
 822                         gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 823                                 gtk_adjustment_get_value(event_viewer_data->vadjust_c) - 1);
 824                         break;
 825                 case GDK_SCROLL_DOWN:
 826                         gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 827                                 gtk_adjustment_get_value(event_viewer_data->vadjust_c) + 1);
 828                         break;
 829                 default:
 830                         g_error("Only scroll up and down expected");
 831         }
 832         return TRUE;
 833 }
 834
 835 void tree_v_cursor_changed_cb (GtkWidget *widget, gpointer data)
 836 {
 837
 838   EventViewerData *event_viewer_data = (EventViewerData*) data;
 839
 840   Tab *tab = event_viewer_data->tab;
 841   GtkTreeIter iter;
 842   GtkTreeModel* model = GTK_TREE_MODEL(event_viewer_data->store_m);
 843   GtkTreePath *path;
 844   LttvTracesetPosition *pos;
 845
 846   g_debug("cursor changed cb");
 847
 848   /* On cursor change, modify the currently selected event by calling
 849    * the right API function */
 850   if(event_viewer_data->report_position) {
 851     if(event_viewer_data->pos->len > 0) {
 852                         gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 853                                         &path, NULL);
 854                         if(path) {
 855                                 if(gtk_tree_model_get_iter(model,&iter,path)){
 856                                         gtk_tree_model_get(model, &iter, POSITION_COLUMN, &pos, -1);
 857
 858                                         if(lttv_traceset_position_compare(pos,
 859                                                                             event_viewer_data->currently_selected_position) != 0) {
 860                                                 lttvwindow_report_current_position(tab, pos);
 861                                         }
 862                                 }else{
 863                                         g_warning("Can not get iter\n");
 864                                 }
 865                                 gtk_tree_path_free(path);
 866                         }
 867                 }
 868         }
 869 }
 870
 871
 872 static void tree_selection_changed_cb (GtkTreeSelection *selection,
 873     gpointer data)
 874 {
 875   g_debug("tree sel changed cb - do nothing");
 876
 877
 878 }
 879
 880 #if 0
 881 static gint key_snooper(GtkWidget *grab_widget, GdkEventKey *event,
 882     gpointer func_data)
 883 {
 884   return TRUE;
 885 }
 886 #endif //0
 887
 888 /* This callback may be recalled after a step up/down, but we don't want to lose
 889  * the exact position : what we do is that we only set the value if it has
 890  * changed : a step up/down that doesn't change the time value of the first
 891  * event won't trigger a scrollbar change. */
 892
 893 void v_scroll_cb (GtkAdjustment *adjustment, gpointer data)
 894 {
 895   EventViewerData *event_viewer_data = (EventViewerData*)data;
 896   g_debug("SCROLL begin");
 897   g_debug("SCROLL values : %g , %g, %g",
 898       adjustment->value, event_viewer_data->previous_value,
 899       (adjustment->value - event_viewer_data->previous_value));
 900
 901   LttTime new_time_off = ltt_time_from_double(adjustment->value);
 902   LttTime old_time_off = ltt_time_from_double(event_viewer_data->previous_value);
 903   g_debug("SCROLL time values %lu.%lu, %lu.%lu", new_time_off.tv_sec,
 904       new_time_off.tv_nsec, old_time_off.tv_sec, old_time_off.tv_nsec);
 905   /* If same value : nothing to update */
 906   if(ltt_time_compare(new_time_off, old_time_off) == 0)
 907     return;
 908
 909   //LttTime old_time = event_viewer_data->first_event;
 910
 911
 912   //gint snoop = gtk_key_snooper_install(key_snooper, NULL);
 913
 914   adjust_event_viewer(adjustment->value, event_viewer_data);
 915
 916   //gtk_key_snooper_remove(snoop);
 917
 918   g_debug("SCROLL end");
 919 }
 920
 921 static __inline gint get_cell_height(GtkTreeView *TreeView)
 922 {
 923   gint height;
 924   GtkTreeViewColumn *column = gtk_tree_view_get_column(TreeView, 0);
 925
 926   gtk_tree_view_column_cell_get_size(column, NULL, NULL, NULL, NULL, &height);
 927
 928   gint vertical_separator;
 929   gtk_widget_style_get (GTK_WIDGET (TreeView),
 930       "vertical-separator", &vertical_separator,
 931       NULL);
 932
 933         height += vertical_separator;
 934
 935   return height;
 936 }
 937
 938 void tree_v_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data)
 939 {
 940   EventViewerData *event_viewer_data = (EventViewerData*)data;
 941   gint cell_height = get_cell_height(GTK_TREE_VIEW(event_viewer_data->tree_v));
 942   gint last_num_visible_events = event_viewer_data->num_visible_events;
 943   gdouble exact_num_visible;
 944
 945   exact_num_visible = ( alloc->height -
 946           event_viewer_data->header_height )
 947             / (double)cell_height ;
 948
 949   event_viewer_data->num_visible_events = ceil(exact_num_visible) ;
 950
 951   event_viewer_data->vadjust_c->page_increment =
 952                                         floor(exact_num_visible);
 953   event_viewer_data->vadjust_c->page_size =
 954                                         floor(exact_num_visible);
 955
 956
 957   g_debug("size allocate %p : last_num_visible_events : %d",
 958            event_viewer_data, last_num_visible_events);
 959   g_debug("num_visible_events : %d, value %f",
 960            event_viewer_data->num_visible_events,
 961            event_viewer_data->vadjust_c->value);
 962
 963   if(event_viewer_data->num_visible_events != last_num_visible_events) {
 964     //TODO ybrosseau do a proper initialisation here, so we can use the redraw
 965     adjust_event_viewer(event_viewer_data->vadjust_c->value, event_viewer_data);
 966     //redraw(event_viewer_data);
 967   }
 968
 969
 970 }
 971
 972 void tree_v_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data)
 973 {
 974   gint h;
 975   EventViewerData *event_viewer_data = (EventViewerData*)data;
 976   gint cell_height = get_cell_height(GTK_TREE_VIEW(event_viewer_data->tree_v));
 977
 978   h = cell_height + event_viewer_data->header_height;
 979   requisition->height = h;
 980
 981 }
 982
 983 static gboolean events_check_handler(guint count, gboolean *stop_flag,
 984   gpointer data)
 985 {
 986   EventViewerData *evd = (EventViewerData*)data;
 987   if(count % CHECK_GDK_INTERVAL == 0) {
 988     GdkEvent *event;
 989     GtkWidget *widget;
 990     while((event = gdk_event_get()) != NULL) {
 991         widget = gtk_get_event_widget(event);
 992         if(widget ==
 993           lookup_widget(main_window_get_widget(evd->tab),
 994               "StopProcessingButton")
 995           || widget == evd->vscroll_vc) {
 996           gtk_main_do_event(event);
 997           gdk_window_process_all_updates();
 998         }
 999         gdk_event_free(event);
1000     }
1001     if(*stop_flag)
1002       return TRUE;
1003     else
1004       return FALSE;
1005   } else return FALSE;
1006 }
1007
1008
1009 /* This function will adjust the first event position for the viewer which
1010    will be used by the redraw to seek and display all the events
1011  */
1012 static void adjust_event_viewer(double new_value, EventViewerData *event_viewer_data)
1013 {
1014 #ifdef BABEL_CLEANUP
1015   LttvTracesetStats *tss =
1016     lttvwindow_get_traceset_stats(event_viewer_data->tab);
1017 #endif //babel_cleanup
1018   LttvTraceset *ts = lttvwindow_get_traceset(event_viewer_data->tab);
1019
1020   gboolean seek_by_time;
1021
1022   if(lttvwindow_preempt_count > 0) return;
1023
1024   double value = new_value - event_viewer_data->previous_value;
1025
1026   /* Set stop button status for foreground processing */
1027   event_viewer_data->tab->stop_foreground = FALSE;
1028   lttvwindow_events_request_disable();
1029
1030   /* See where we have to scroll... */
1031   ScrollDirection direction;
1032   gint relative_position;
1033
1034   if(value < -0.8) {
1035     if(value >= -1.0) direction = SCROLL_STEP_UP;
1036     else {
1037       if(value >= -2.0) direction = SCROLL_PAGE_UP;
1038       else direction = SCROLL_JUMP;
1039     }
1040   } else if(value > 0.8) {
1041     if(value <= 1.0) direction = SCROLL_STEP_DOWN;
1042     else {
1043       if(value <= 2.0) direction = SCROLL_PAGE_DOWN;
1044       else direction = SCROLL_JUMP;
1045     }
1046   } else direction = SCROLL_NONE; /* 0.0 */
1047
1048   switch(direction) {
1049   case SCROLL_STEP_UP:
1050     g_debug("adjust_event_viewer : SCROLL_STEP_UP");
1051     relative_position = -1;
1052     seek_by_time = 0;
1053     break;
1054   case SCROLL_STEP_DOWN:
1055     g_debug("adjust_event_viewer : SCROLL_STEP_DOWN");
1056     relative_position = 1;
1057     seek_by_time = 0;
1058     break;
1059   case SCROLL_PAGE_UP:
1060     g_debug("adjust_event_viewer : SCROLL_PAGE_UP");
1061     relative_position = -(event_viewer_data->num_visible_events);
1062     seek_by_time = 0;
1063     break;
1064   case SCROLL_PAGE_DOWN:
1065     g_debug("adjust_event_viewer : SCROLL_PAGE_DOWN");
1066     relative_position = event_viewer_data->num_visible_events;
1067     seek_by_time = 0;
1068     break;
1069   case SCROLL_JUMP:
1070     g_debug("adjust_event_viewer : SCROLL_JUMP");
1071     relative_position = 0;
1072     seek_by_time = 1;
1073     break;
1074   case SCROLL_NONE:
1075     g_debug("adjust_event_viewer : SCROLL_NONE");
1076     relative_position = 0;
1077     seek_by_time = 0;
1078     break;
1079   }
1080
1081   LttTime time = ltt_time_from_double(new_value);
1082   TimeInterval time_span = lttv_traceset_get_time_span_real(ts);
1083   time = ltt_time_add(time_span.start_time, time);
1084
1085   LttvTracesetPosition *timePos = lttv_traceset_create_time_position(ts,time);
1086
1087
1088   if(!seek_by_time) {
1089
1090     /* Remember the beginning position */
1091     if(event_viewer_data->pos->len > 0) {
1092
1093       if(relative_position != 0)
1094       {
1095         LttvTracesetPosition *pos = 0;
1096         pos = (LttvTracesetPosition*)g_ptr_array_index(
1097                                                 event_viewer_data->pos,
1098                                                 0);
1099         lttv_state_traceset_seek_position(ts,pos);
1100       }
1101     } else {
1102       lttv_state_traceset_seek_time(ts,time);
1103
1104     }
1105
1106   /* Note that, as we mess with the tsc position, this function CANNOT be called
1107    * from a hook inside the lttv_process_traceset_middle. */
1108   /* As the lttvwindow API keeps a sync_position inside the tsc to go back at
1109    * the right spot after being interrupted, it's ok to change the tsc position,
1110    * as long as we do not touch the sync_position. */
1111
1112   /* Get the beginning position of the read (with seek backward or seek forward)
1113    */
1114     if(relative_position > 0) {
1115       lttv_process_traceset_seek_n_forward(ts, relative_position,
1116           events_check_handler,
1117           &event_viewer_data->tab->stop_foreground,
1118           event_viewer_data->main_win_filter,
1119           event_viewer_data->filter, NULL, event_viewer_data);
1120     } else if(relative_position < 0) {
1121       /* Get an idea of currently shown event dispersion */
1122       guint64 first_event_time_stamp =
1123         lttv_traceset_position_get_timestamp(event_viewer_data->first_event);
1124       guint64 last_event_time_stamp =
1125         lttv_traceset_position_get_timestamp(event_viewer_data->last_event);
1126       guint64 timeSpan = (last_event_time_stamp - first_event_time_stamp);
1127       gdouble ratio =  (gdouble)timeSpan / (gdouble)event_viewer_data->num_visible_events;
1128       if(ratio <= 0){
1129         ratio = SEEK_BACK_DEFAULT_RATIO;
1130       }
1131
1132       lttv_process_traceset_seek_n_backward(ts,
1133           (guint)abs(relative_position),
1134           ratio,
1135           events_check_handler,
1136           &event_viewer_data->tab->stop_foreground,
1137           event_viewer_data->main_win_filter,
1138           event_viewer_data->filter, NULL, event_viewer_data);
1139     } /* else 0 : do nothing : we are already at the beginning position */
1140
1141     /* Save the first event position */
1142
1143     event_viewer_data->first_event = lttv_traceset_create_current_position(ts);
1144
1145     time = ltt_time_from_uint64(lttv_traceset_position_get_timestamp(
1146                                             event_viewer_data->first_event));
1147     //if(ltt_time_compare(time, tsc->time_span.end_time) > 0)
1148     //  time = tsc->time_span.end_time;
1149
1150     LttTime time_val = ltt_time_sub(time,time_span.start_time);
1151     event_viewer_data->previous_value = ltt_time_to_double(time_val);
1152
1153
1154   } else {
1155     /* Seek by time */
1156
1157     LttTime time_val = ltt_time_sub(time,time_span.start_time);
1158     event_viewer_data->previous_value = ltt_time_to_double(time_val);
1159     event_viewer_data->first_event = timePos;
1160   }
1161   lttvwindow_events_request_enable();
1162
1163   redraw(event_viewer_data);
1164 }
1165
1166 static void redraw(EventViewerData *event_viewer_data) {
1167   guint i;
1168   LttvTraceset *ts = lttvwindow_get_traceset(event_viewer_data->tab);
1169
1170   g_debug("EventViewer redraw");
1171
1172   //TODO ybrosseau verify its still required
1173   lttvwindow_events_request_disable();
1174
1175
1176   /* Clear the model (don't forget to free the TCS positions!) */
1177   gtk_list_store_clear(event_viewer_data->store_m);
1178   for(i=0;i<event_viewer_data->pos->len;i++) {
1179     LttvTracesetPosition *cur_pos =
1180       (LttvTracesetPosition*)g_ptr_array_index(event_viewer_data->pos,
1181                                                       i);
1182     lttv_traceset_destroy_position(cur_pos);
1183   }
1184   g_ptr_array_set_size(event_viewer_data->pos, 0);
1185
1186   lttv_state_traceset_seek_position(ts, event_viewer_data->first_event);
1187
1188   /* Mathieu :
1189    * I make the choice not to use the mainwindow lttvwindow API here : the idle
1190    * loop might have a too low priority, and we want good update while
1191    * scrolling. However, we call the gdk loop to get events periodically so the
1192    * processing can be stopped.
1193    */
1194
1195   lttv_process_traceset_begin(ts,
1196       NULL, NULL, event_viewer_data->event_hooks);
1197
1198   event_viewer_data->num_events = 0;
1199
1200   lttv_process_traceset_middle(ts, ltt_time_infinite, G_MAXUINT, NULL);
1201
1202   lttv_process_traceset_end(ts, NULL, NULL, event_viewer_data->event_hooks);
1203
1204   /* Get the end position */
1205   if(event_viewer_data->pos->len > 0) {
1206     LttvTracesetPosition *cur_pos =
1207       (LttvTracesetPosition*)g_ptr_array_index(event_viewer_data->pos,
1208                                                event_viewer_data->pos->len - 1);
1209     event_viewer_data->last_event = cur_pos;
1210   } else
1211         event_viewer_data->last_event =lttv_traceset_create_current_position(ts);
1212
1213   gtk_adjustment_set_value(event_viewer_data->vadjust_c,
1214       event_viewer_data->previous_value);
1215
1216   //g_signal_emit_by_name(G_OBJECT (event_viewer_data->select_c),
1217   //    "changed");
1218
1219   event_viewer_data->last_tree_update_time =
1220     gdk_x11_get_server_time(
1221         gtk_widget_get_parent_window(event_viewer_data->tree_v));
1222
1223   lttvwindow_events_request_enable();
1224
1225   return;
1226 }
1227
1228
1229 int event_hook(void *hook_data, void *call_data)
1230 {
1231
1232   EventViewerData *event_viewer_data = (EventViewerData*)hook_data;
1233
1234   LttvEvent * e = (LttvEvent *)call_data;
1235
1236   if(event_viewer_data->num_events % CHECK_GDK_INTERVAL == 0) {
1237     GdkEvent *event;
1238     GtkWidget *widget;
1239     while((event = gdk_event_get()) != NULL) {
1240         widget = gtk_get_event_widget(event);
1241         if(widget ==
1242           lookup_widget(main_window_get_widget(event_viewer_data->tab),
1243               "StopProcessingButton")
1244           || widget == event_viewer_data->vscroll_vc) {
1245           gtk_main_do_event(event);
1246           gdk_window_process_all_updates();
1247         }
1248         gdk_event_free(event);
1249     }
1250     //gtk_main_iteration_do(FALSE);
1251     if(event_viewer_data->tab->stop_foreground)
1252       return TRUE;
1253   }
1254
1255   event_viewer_data->num_events++;
1256 #ifdef BABEL_CLEANUP
1257   LttvFilter *filter = event_viewer_data->main_win_filter;
1258   if(filter != NULL && filter->head != NULL)
1259     if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1260           tfc->t_context->t,tfc,NULL,NULL))
1261       return FALSE;
1262
1263   filter = event_viewer_data->filter;
1264   if(filter != NULL && filter->head != NULL)
1265     if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1266           tfc->t_context->t,tfc,NULL,NULL))
1267       return FALSE;
1268 #endif //babel_cleanup
1269
1270 //  LttFacility *facility = ltt_event_facility(e);
1271 //  LttEventType *event_type = ltt_event_eventtype(e);
1272   LttTime time = lttv_event_get_timestamp(e);
1273   gint cpu = lttv_traceset_get_cpuid_from_event(e);
1274
1275   LttvTraceState *traceState = e->state;
1276   LttvProcessState *process = traceState->running_process[cpu];
1277
1278   GtkTreeIter iter;
1279
1280   GString *desc = g_string_new("");
1281   GString *name = g_string_new("");
1282
1283   LttvTracesetPosition *pos = lttv_traceset_create_current_position(traceState->trace->traceset);
1284
1285   lttv_event_to_string(e, desc, TRUE, FALSE);
1286   lttv_event_get_name(e,name);
1287
1288   g_info("detail : %s", desc->str);
1289
1290   gtk_list_store_append (event_viewer_data->store_m, &iter);
1291
1292   gtk_list_store_set (event_viewer_data->store_m, &iter,
1293         TRACE_NAME_COLUMN, traceState->trace->short_name,
1294         CPUID_COLUMN, cpu,
1295         EVENT_COLUMN,name->str,
1296         TIME_S_COLUMN, time.tv_sec,
1297         TIME_NS_COLUMN, time.tv_nsec,
1298         PID_COLUMN, process->pid,
1299         EVENT_DESCR_COLUMN, desc->str,
1300         POSITION_COLUMN, pos,
1301         -1);
1302
1303   g_ptr_array_add(event_viewer_data->pos, pos);
1304
1305   g_string_free(desc, TRUE);
1306   g_string_free(name, TRUE);
1307
1308   if(event_viewer_data->update_cursor) {
1309     if(lttv_traceset_position_compare(pos,
1310           event_viewer_data->currently_selected_position) == 0) {
1311       GtkTreePath *path = gtk_tree_path_new_from_indices(
1312                           event_viewer_data->pos->len - 1, -1);
1313                         if(path) {
1314               gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
1315                                    path, NULL, FALSE);
1316           gtk_tree_path_free(path);
1317                         }
1318     }
1319   }
1320   if(event_viewer_data->pos->len >= event_viewer_data->num_visible_events )
1321     return TRUE;
1322   else
1323     return FALSE;
1324
1325 }
1326
1327
1328
1329 static void event_update_selection(EventViewerData *event_viewer_data)
1330 {
1331
1332   guint i;
1333   GPtrArray *positions = event_viewer_data->pos;
1334   g_info("event_update_selection");
1335
1336   int isFound = FALSE;
1337
1338
1339   for(i=0;i<positions->len;i++) {
1340     LttvTracesetPosition *cur_pos =
1341                 (LttvTracesetPosition*)g_ptr_array_index(positions, i);
1342     if(lttv_traceset_position_compare(cur_pos,
1343           event_viewer_data->currently_selected_position) == 0) {
1344       GtkTreePath *path = gtk_tree_path_new_from_indices(i, -1);
1345                         if(path) {
1346               gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
1347                                      path, NULL, FALSE);
1348               gtk_widget_grab_focus(event_viewer_data->tree_v );
1349               gtk_tree_path_free(path);
1350               isFound = TRUE;
1351               break;
1352                         }
1353     }
1354   }
1355         if(isFound){
1356           return;
1357         }
1358   /* If the current selection is not in the currently displayed events*/
1359   LttTime currentTime = lttv_traceset_position_get_time(
1360                                 event_viewer_data->currently_selected_position);
1361   LttTime time;
1362
1363   LttvTraceset * ts = lttvwindow_get_traceset(event_viewer_data->tab);
1364   TimeInterval time_span = lttv_traceset_get_time_span_real(ts);
1365   time = ltt_time_sub(currentTime, time_span.start_time);
1366   gtk_adjustment_set_value(event_viewer_data->vadjust_c,
1367                                                 ltt_time_to_double(time));
1368   gtk_widget_grab_focus(event_viewer_data->tree_v );
1369
1370 }
1371 #ifdef BABEL_CLEANUP
1372 static int current_time_get_first_event_hook(void *hook_data, void *call_data)
1373 {
1374
1375   EventViewerData *event_viewer_data = (EventViewerData*)hook_data;
1376
1377   LttvTracefileContext *tfc = (LttvTracefileContext*)call_data;
1378   LttEvent *e = ltt_tracefile_get_event(tfc->tf);
1379
1380   LttvFilter *filter = event_viewer_data->main_win_filter;
1381   if(filter != NULL && filter->head != NULL)
1382     if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1383           tfc->t_context->t,tfc,NULL,NULL))
1384       return FALSE;
1385
1386   filter = event_viewer_data->filter;
1387   if(filter != NULL && filter->head != NULL)
1388     if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1389           tfc->t_context->t,tfc,NULL,NULL))
1390       return FALSE;
1391
1392   lttv_traceset_context_position_save(tfc->t_context->ts_context,
1393       event_viewer_data->current_time_get_first);
1394   return TRUE;
1395
1396
1397 }
1398 #endif // BABEL_CLEANUP
1399
1400 gboolean update_current_time(void * hook_data, void * call_data)
1401 {
1402
1403         //LttvEvent * e = (LttvEvent *)call_data;
1404   g_info("update_current_time");
1405   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1406
1407   const LttTime * current_time = (LttTime*)call_data;
1408   LttvTraceset * ts = lttvwindow_get_traceset(event_viewer_data->tab);
1409
1410   /* If the currently selected event time != current time, set the first event
1411    * with this time as currently selected. */
1412   LttTime pos_time = lttv_traceset_position_get_time(
1413                         event_viewer_data->currently_selected_position);
1414
1415   if(ltt_time_compare(pos_time, *current_time) != 0) {
1416         /*create position*/
1417         //LttvTracesetPosition *currentPosition =
1418         //                lttv_traceset_create_time_position(ts,*current_time );
1419         /*seek to current position*/
1420         lttv_state_traceset_seek_time(ts, *current_time);
1421
1422         event_viewer_data->currently_selected_position =
1423           lttv_traceset_create_current_position(ts);
1424         g_debug("update_current_time: %p %d", event_viewer_data->currently_selected_position,  event_viewer_data->currently_selected_position->timestamp);
1425   }
1426
1427   event_viewer_data->report_position = FALSE;
1428
1429     /* Simply update the current time : it is in the list */
1430   event_update_selection(event_viewer_data);
1431   event_viewer_data->report_position = TRUE;
1432
1433   return FALSE;
1434 }
1435
1436 gboolean update_current_position(void * hook_data, void * call_data)
1437 {
1438
1439   g_info("update_current_position");
1440   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1441   const LttvTracesetPosition *current_pos = (LttvTracesetPosition*)call_data;
1442
1443   if(lttv_traceset_position_compare(
1444         event_viewer_data->currently_selected_position, current_pos) != 0) {
1445     g_debug("Update current pos: %p, %d", current_pos, current_pos->timestamp);
1446                 event_viewer_data->currently_selected_position = current_pos;
1447       /* Simply update the current time : it is in the list */
1448       event_update_selection(event_viewer_data);
1449     }
1450   return FALSE;
1451
1452 }
1453
1454 gboolean timespan_changed(void * hook_data, void * call_data)
1455 {
1456
1457   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1458   LttvTraceset * ts = lttvwindow_get_traceset(event_viewer_data->tab);
1459   TimeInterval time_span = lttv_traceset_get_time_span_real(ts);
1460
1461   LttTime end;
1462
1463   end = ltt_time_sub(time_span.end_time, time_span.start_time);
1464   event_viewer_data->vadjust_c->upper = ltt_time_to_double(end);
1465
1466   if(event_viewer_data->pos->len < event_viewer_data->num_visible_events ) {
1467
1468
1469     redraw(event_viewer_data);
1470
1471           request_background_data(event_viewer_data);
1472   }
1473   return FALSE;
1474 }
1475
1476 gboolean traceset_changed(void * hook_data, void * call_data)
1477 {
1478
1479   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1480   LttvTraceset * ts = lttvwindow_get_traceset(event_viewer_data->tab);
1481   TimeInterval time_span = lttv_traceset_get_time_span_real(ts);
1482
1483   LttTime end;
1484   gtk_list_store_clear(event_viewer_data->store_m);
1485   g_ptr_array_set_size(event_viewer_data->pos, 0);
1486
1487   end = ltt_time_sub(time_span.end_time, time_span.start_time);
1488   event_viewer_data->vadjust_c->upper = ltt_time_to_double(end);
1489 #ifdef BABEL_CLEANUP
1490   /* Reset the positions */
1491   lttv_traceset_destroy_position(event_viewer_data->currently_selected_position);
1492   lttv_traceset_destroy_position(event_viewer_data->first_event);
1493   lttv_traceset_destroy_position(event_viewer_data->last_event);
1494
1495   event_viewer_data->currently_selected_position =
1496                                 lttv_traceset_create_current_position(ts);
1497   event_viewer_data->first_event =
1498                                 lttv_traceset_create_current_position(ts);
1499   event_viewer_data->last_event =
1500                                 lttv_traceset_create_current_position(ts);
1501
1502   redraw(event_viewer_data);
1503
1504 #endif //babel_cleanup
1505   //  event_viewer_data->vadjust_c->value = 0;
1506
1507         request_background_data(event_viewer_data);
1508
1509   return FALSE;
1510 }
1511
1512 gboolean filter_changed(void * hook_data, void * call_data)
1513 {
1514   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1515
1516   event_viewer_data->main_win_filter =
1517     (LttvFilter*)call_data;
1518   redraw(event_viewer_data);
1519
1520   return FALSE;
1521 }
1522
1523
1524 gint evd_redraw_notify(void *hook_data, void *call_data)
1525 {
1526   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1527
1528   redraw(event_viewer_data);
1529   return 0;
1530 }
1531
1532 void gui_events_free(gpointer data)
1533 {
1534 #ifdef BABEL_CLEANUP
1535   LttvPluginEVD *plugin_evd = (LttvPluginEVD*)data;
1536   Tab *tab = plugin_evd->evd->tab;
1537   EventViewerData *event_viewer_data = plugin_evd->evd;
1538   guint i;
1539
1540   lttv_filter_destroy(plugin_evd->evd->filter);
1541
1542   if(tab != NULL){
1543     lttv_hooks_remove(event_viewer_data->event_hooks,event_hook);
1544     lttv_hooks_destroy(event_viewer_data->event_hooks);
1545
1546     for(i=0;i<event_viewer_data->pos->len;i++) {
1547       LttvTracesetContextPosition *cur_pos =
1548         (LttvTracesetContextPosition*)g_ptr_array_index(event_viewer_data->pos,
1549                                                         i);
1550       lttv_traceset_context_position_destroy(cur_pos);
1551     }
1552     lttv_traceset_context_position_destroy(
1553         event_viewer_data->currently_selected_position);
1554     lttv_traceset_context_position_destroy(
1555         event_viewer_data->first_event);
1556     lttv_traceset_context_position_destroy(
1557         event_viewer_data->last_event);
1558     g_ptr_array_free(event_viewer_data->pos, TRUE);
1559
1560     lttvwindow_unregister_current_time_notify(tab,
1561                         update_current_time, event_viewer_data);
1562     lttvwindow_unregister_current_position_notify(tab,
1563                         update_current_position, event_viewer_data);
1564     //lttvwindow_unregister_show_notify(tab,
1565     //                    show_event_detail, event_viewer_data);
1566     lttvwindow_unregister_traceset_notify(tab,
1567                         traceset_changed, event_viewer_data);
1568     lttvwindow_unregister_timespan_notify(tab,
1569                                     timespan_changed,event_viewer_data);
1570     lttvwindow_unregister_filter_notify(tab,
1571                         filter_changed, event_viewer_data);
1572     lttvwindow_unregister_redraw_notify(tab,
1573                 evd_redraw_notify, event_viewer_data);
1574
1575   }
1576   lttvwindowtraces_background_notify_remove(event_viewer_data);
1577
1578   g_event_viewer_data_list = g_slist_remove(g_event_viewer_data_list,
1579       event_viewer_data);
1580   //g_free(event_viewer_data);
1581   g_object_unref(plugin_evd);
1582 #endif // BABEL_CLEANUP
1583 }
1584
1585
1586
1587 void gui_events_destructor(gpointer data)
1588 {
1589   LttvPluginEVD *plugin_evd = (LttvPluginEVD*)data;
1590   /* May already been done by GTK window closing */
1591   if(GTK_IS_WIDGET(plugin_evd->parent.top_widget)){
1592     gtk_widget_destroy(plugin_evd->parent.top_widget);
1593   }
1594 }
1595
1596
1597
1598 /**
1599  * plugin's init function
1600  *
1601  * This function initializes the Event Viewer functionnality through the
1602  * gtkTraceSet API.
1603  */
1604 static void init() {
1605
1606   lttvwindow_register_constructor("guievents",
1607                                   "/",
1608                                   "Insert Event Viewer",
1609                                   hGuiEventsInsert_xpm,
1610                                   "Insert Event Viewer",
1611                                   h_gui_events);
1612 }
1613
1614 void event_destroy_walk(gpointer data, gpointer user_data)
1615 {
1616   gui_events_destructor((LttvPluginEVD*)data);
1617 }
1618
1619 /**
1620  * plugin's destroy function
1621  *
1622  * This function releases the memory reserved by the module and unregisters
1623  * everything that has been registered in the gtkTraceSet API.
1624  */
1625 static void destroy() {
1626
1627   g_slist_foreach(g_event_viewer_data_list, event_destroy_walk, NULL );
1628   g_slist_free(g_event_viewer_data_list);
1629
1630   lttvwindow_unregister_constructor(h_gui_events);
1631
1632 }
1633
1634
1635
1636
1637 LTTV_MODULE("guievents", "Detailed events view", \
1638     "Graphical module to display a detailed event list", \
1639             init, destroy, "lttvwindow", "print")