ltt/branches/poly/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 <gtk/gtk.h>
  51 #include <gdk/gdk.h>
  52 #include <gdk/gdkx.h>
  53 #include <string.h>
  54
  55 #include <ltt/ltt.h>
  56 #include <ltt/event.h>
  57 #include <ltt/type.h>
  58 #include <ltt/trace.h>
  59 #include <ltt/facility.h>
  60 #include <lttv/module.h>
  61 #include <lttv/hook.h>
  62 #include <lttv/tracecontext.h>
  63 #include <lttv/state.h>
  64 #include <lttv/filter.h>
  65 #include <lttv/print.h>
  66 #include <lttvwindow/lttvwindow.h>
  67 #include <lttvwindow/lttvwindowtraces.h>
  68 #include <lttvwindow/lttv_plugin_tab.h>
  69 #include <lttvwindow/support.h>
  70 #include "lttv_plugin_evd.h"
  71
  72 #include "events.h"
  73 #include "hGuiEventsInsert.xpm"
  74
  75 #define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format)
  76
  77 #ifndef g_debug
  78 #define g_debug(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format)
  79 #endif
  80
  81 #define abs(a) (((a)<0)?(-a):(a))
  82 #define max(a,b) ((a)>(b)?(a):(b))
  83 #define min(a,b) ((a)<(b)?(a):(b))
  84
  85 /** Array containing instanced objects. Used when module is unloaded */
  86 static GSList *g_event_viewer_data_list = NULL ;
  87
  88 typedef enum _ScrollDirection{
  89   SCROLL_STEP_UP,
  90   SCROLL_STEP_DOWN,
  91   SCROLL_PAGE_UP,
  92   SCROLL_PAGE_DOWN,
  93   SCROLL_JUMP,
  94   SCROLL_NONE
  95 } ScrollDirection;
  96
  97 /** hook functions for update time interval, current time ... */
  98 gboolean update_current_time(void * hook_data, void * call_data);
  99 gboolean update_current_position(void * hook_data, void * call_data);
 100 //gboolean show_event_detail(void * hook_data, void * call_data);
 101 gboolean traceset_changed(void * hook_data, void * call_data);
 102 gboolean filter_changed(void * hook_data, void * call_data);
 103
 104 static void request_background_data(EventViewerData *event_viewer_data);
 105
 106 //! Event Viewer's constructor hook
 107 GtkWidget *h_gui_events(LttvPlugin *plugin);
 108 //! Event Viewer's constructor
 109 EventViewerData *gui_events(LttvPluginTab *ptab);
 110 //! Event Viewer's destructor
 111 void gui_events_destructor(gpointer data);
 112 void gui_events_free(gpointer data);
 113
 114 static gboolean
 115 header_size_allocate(GtkWidget *widget,
 116                         GtkAllocation *allocation,
 117                         gpointer user_data);
 118
 119 void tree_v_set_cursor(EventViewerData *event_viewer_data);
 120 void tree_v_get_cursor(EventViewerData *event_viewer_data);
 121
 122 /* Prototype for selection handler callback */
 123 static void tree_selection_changed_cb (GtkTreeSelection *selection,
 124     gpointer data);
 125 static void v_scroll_cb (GtkAdjustment *adjustment, gpointer data);
 126 static void tree_v_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc,
 127     gpointer data);
 128 static void tree_v_size_request_cb (GtkWidget *widget,
 129     GtkRequisition *requisition, gpointer data);
 130 static void tree_v_cursor_changed_cb (GtkWidget *widget, gpointer data);
 131 static void tree_v_move_cursor_cb (GtkWidget *widget, GtkMovementStep arg1,
 132     gint arg2, gpointer data);
 133 static void        filter_button      (GtkToolButton *toolbutton,
 134                                           gpointer       user_data);
 135 static gboolean tree_v_scroll_handler (GtkWidget *widget, GdkEventScroll *event, gpointer data);
 136 static gboolean key_handler(GtkWidget *widget, GdkEventKey *event,
 137     gpointer user_data);
 138
 139 static void get_events(double time, EventViewerData *event_viewer_data);
 140
 141 int event_hook(void *hook_data, void *call_data);
 142
 143 /* Enumeration of the columns */
 144 enum
 145 {
 146   TRACE_NAME_COLUMN,
 147   TRACEFILE_NAME_COLUMN,
 148   CPUID_COLUMN,
 149   EVENT_COLUMN,
 150   FACILITY_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   LttTime end;
 188   GtkTreeViewColumn *column;
 189   GtkCellRenderer *renderer;
 190   EventViewerData* event_viewer_data = g_new(EventViewerData,1);
 191   LttvPluginEVD *plugin_evd = g_object_new(LTTV_TYPE_PLUGIN_EVD, NULL);
 192   plugin_evd->evd = event_viewer_data;
 193   Tab *tab = ptab->tab;
 194   event_viewer_data->tab = tab;
 195   event_viewer_data->ptab = ptab;
 196   GtkWidget *tmp_toolbar_icon;
 197
 198   LttvTracesetContext * tsc =
 199         lttvwindow_get_traceset_context(event_viewer_data->tab);
 200
 201
 202   event_viewer_data->event_hooks = lttv_hooks_new();
 203   lttv_hooks_add(event_viewer_data->event_hooks,
 204                  event_hook,
 205                  event_viewer_data,
 206                  LTTV_PRIO_DEFAULT);
 207
 208   lttvwindow_register_current_time_notify(tab,
 209                 update_current_time,event_viewer_data);
 210   lttvwindow_register_current_position_notify(tab,
 211                 update_current_position,event_viewer_data);
 212   lttvwindow_register_traceset_notify(tab,
 213                 traceset_changed,event_viewer_data);
 214   lttvwindow_register_filter_notify(tab,
 215                 filter_changed, event_viewer_data);
 216   lttvwindow_register_redraw_notify(tab,
 217                 evd_redraw_notify, event_viewer_data);
 218
 219
 220   event_viewer_data->scroll_win = gtk_scrolled_window_new (NULL, NULL);
 221   gtk_widget_show (event_viewer_data->scroll_win);
 222   gtk_scrolled_window_set_policy(
 223       GTK_SCROLLED_WINDOW(event_viewer_data->scroll_win),
 224       GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
 225
 226   event_viewer_data->currently_selected_position =
 227     lttv_traceset_context_position_new(tsc);
 228   event_viewer_data->first_event =
 229     lttv_traceset_context_position_new(tsc);
 230   event_viewer_data->last_event =
 231     lttv_traceset_context_position_new(tsc);
 232
 233   event_viewer_data->main_win_filter = lttvwindow_get_filter(tab);
 234
 235   event_viewer_data->update_cursor = TRUE;
 236   event_viewer_data->report_position = TRUE;
 237
 238   event_viewer_data->last_tree_update_time = 0;
 239
 240   event_viewer_data->init_done = 0;
 241
 242   /* Create a model for storing the data list */
 243   event_viewer_data->store_m = gtk_list_store_new (
 244     N_COLUMNS,      /* Total number of columns     */
 245     G_TYPE_STRING,  /* Trace name                  */
 246     G_TYPE_STRING,  /* Tracefile name              */
 247     G_TYPE_UINT,    /* CPUID                       */
 248     G_TYPE_STRING,  /* Event                       */
 249     G_TYPE_STRING,  /* Facility                    */
 250     G_TYPE_UINT,    /* Time s                      */
 251     G_TYPE_UINT,    /* Time ns                     */
 252     G_TYPE_INT,     /* PID                         */
 253     G_TYPE_STRING,  /* Event's description         */
 254     G_TYPE_POINTER);/* Position (not shown)        */
 255
 256   event_viewer_data->pos = g_ptr_array_sized_new(10);
 257
 258   /* Create the viewer widget for the columned list */
 259   event_viewer_data->tree_v =
 260     gtk_tree_view_new_with_model (GTK_TREE_MODEL (event_viewer_data->store_m));
 261
 262   g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "size-allocate",
 263         G_CALLBACK (tree_v_size_allocate_cb),
 264         event_viewer_data);
 265   g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "size-request",
 266         G_CALLBACK (tree_v_size_request_cb),
 267         event_viewer_data);
 268
 269   g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "cursor-changed",
 270         G_CALLBACK (tree_v_cursor_changed_cb),
 271         event_viewer_data);
 272
 273   g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "move-cursor",
 274         G_CALLBACK (tree_v_move_cursor_cb),
 275         event_viewer_data);
 276
 277   g_signal_connect (G_OBJECT(event_viewer_data->tree_v), "key-press-event",
 278       G_CALLBACK(key_handler),
 279       event_viewer_data);
 280
 281   g_signal_connect (G_OBJECT(event_viewer_data->tree_v), "scroll-event",
 282       G_CALLBACK(tree_v_scroll_handler),
 283       event_viewer_data);
 284
 285
 286
 287   // Use on each column!
 288   //gtk_tree_view_column_set_sizing(event_viewer_data->tree_v,
 289   //GTK_TREE_VIEW_COLUMN_FIXED);
 290
 291   /* The view now holds a reference.  We can get rid of our own
 292    * reference */
 293   g_object_unref (G_OBJECT (event_viewer_data->store_m));
 294
 295
 296   /* Create a column, associating the "text" attribute of the
 297    * cell_renderer to the first column of the model */
 298   /* Columns alignment : 0.0 : Left    0.5 : Center   1.0 : Right */
 299   renderer = gtk_cell_renderer_text_new ();
 300   column = gtk_tree_view_column_new_with_attributes ("Trace",
 301                  renderer,
 302                  "text", TRACE_NAME_COLUMN,
 303                  NULL);
 304   gtk_tree_view_column_set_alignment (column, 0.0);
 305   gtk_tree_view_column_set_fixed_width (column, 120);
 306   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 307       column);
 308
 309   event_viewer_data->button = column->button;
 310
 311   g_signal_connect (G_OBJECT(event_viewer_data->button),
 312         "size-allocate",
 313         G_CALLBACK(header_size_allocate),
 314         (gpointer)event_viewer_data);
 315
 316
 317
 318   renderer = gtk_cell_renderer_text_new ();
 319   column = gtk_tree_view_column_new_with_attributes ("Tracefile",
 320                  renderer,
 321                  "text", TRACEFILE_NAME_COLUMN,
 322                  NULL);
 323   gtk_tree_view_column_set_alignment (column, 0.0);
 324   gtk_tree_view_column_set_fixed_width (column, 120);
 325   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 326       column);
 327
 328
 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),
 337       column);
 338
 339   renderer = gtk_cell_renderer_text_new ();
 340   column = gtk_tree_view_column_new_with_attributes ("Event",
 341                  renderer,
 342                  "text", EVENT_COLUMN,
 343                  NULL);
 344   gtk_tree_view_column_set_alignment (column, 0.0);
 345   gtk_tree_view_column_set_fixed_width (column, 120);
 346   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 347       column);
 348
 349   renderer = gtk_cell_renderer_text_new ();
 350   column = gtk_tree_view_column_new_with_attributes ("Facility",
 351                  renderer,
 352                  "text", FACILITY_COLUMN,
 353                  NULL);
 354   gtk_tree_view_column_set_alignment (column, 0.0);
 355   gtk_tree_view_column_set_fixed_width (column, 120);
 356   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 357       column);
 358
 359   renderer = gtk_cell_renderer_text_new ();
 360   column = gtk_tree_view_column_new_with_attributes ("Time (s)",
 361                  renderer,
 362                  "text", TIME_S_COLUMN,
 363                  NULL);
 364   gtk_tree_view_column_set_alignment (column, 1.0);
 365   gtk_tree_view_column_set_fixed_width (column, 120);
 366   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 367       column);
 368
 369   renderer = gtk_cell_renderer_text_new ();
 370   column = gtk_tree_view_column_new_with_attributes ("Time (ns)",
 371                  renderer,
 372                  "text", TIME_NS_COLUMN,
 373                  NULL);
 374   gtk_tree_view_column_set_alignment (column, 1.0);
 375   gtk_tree_view_column_set_fixed_width (column, 120);
 376   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 377       column);
 378
 379
 380   renderer = gtk_cell_renderer_text_new ();
 381   column = gtk_tree_view_column_new_with_attributes ("PID",
 382                  renderer,
 383                  "text", PID_COLUMN,
 384                  NULL);
 385   gtk_tree_view_column_set_alignment (column, 1.0);
 386   gtk_tree_view_column_set_fixed_width (column, 45);
 387   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 388       column);
 389
 390   renderer = gtk_cell_renderer_text_new ();
 391   column = gtk_tree_view_column_new_with_attributes ("Event Description",
 392                  renderer,
 393                  "text", EVENT_DESCR_COLUMN,
 394                  NULL);
 395   gtk_tree_view_column_set_alignment (column, 0.0);
 396   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 397       column);
 398
 399
 400   /* Setup the selection handler */
 401   event_viewer_data->select_c =
 402     gtk_tree_view_get_selection (GTK_TREE_VIEW (event_viewer_data->tree_v));
 403   gtk_tree_selection_set_mode (event_viewer_data->select_c,
 404       GTK_SELECTION_SINGLE);
 405   g_signal_connect (G_OBJECT (event_viewer_data->select_c), "changed",
 406         G_CALLBACK (tree_selection_changed_cb),
 407         event_viewer_data);
 408
 409   gtk_container_add (GTK_CONTAINER (event_viewer_data->scroll_win),
 410       event_viewer_data->tree_v);
 411
 412   event_viewer_data->hbox_v = gtk_hbox_new(0, 0);
 413   event_viewer_data->top_widget = event_viewer_data->hbox_v;
 414   plugin_evd->parent.top_widget = event_viewer_data->hbox_v;
 415
 416   event_viewer_data->toolbar = gtk_toolbar_new();
 417   gtk_toolbar_set_orientation(GTK_TOOLBAR(event_viewer_data->toolbar),
 418                               GTK_ORIENTATION_VERTICAL);
 419
 420   tmp_toolbar_icon = create_pixmap (main_window_get_widget(tab),
 421       "guifilter16x16.png");
 422   gtk_widget_show(tmp_toolbar_icon);
 423   event_viewer_data->button_filter = gtk_tool_button_new(tmp_toolbar_icon,
 424       "Filter");
 425   g_signal_connect (G_OBJECT(event_viewer_data->button_filter),
 426         "clicked",
 427         G_CALLBACK (filter_button),
 428         (gpointer)plugin_evd);
 429   gtk_toolbar_insert(GTK_TOOLBAR(event_viewer_data->toolbar),
 430       event_viewer_data->button_filter,
 431       0);
 432   gtk_toolbar_set_style(GTK_TOOLBAR(event_viewer_data->toolbar),
 433       GTK_TOOLBAR_ICONS);
 434   gtk_box_pack_start(GTK_BOX(event_viewer_data->hbox_v),
 435       event_viewer_data->toolbar, FALSE, FALSE, 0);
 436   event_viewer_data->filter = NULL;
 437
 438   gtk_box_pack_start(GTK_BOX(event_viewer_data->hbox_v),
 439       event_viewer_data->scroll_win, TRUE, TRUE, 0);
 440
 441   gtk_container_set_border_width(GTK_CONTAINER(event_viewer_data->hbox_v), 1);
 442
 443   /* Create vertical scrollbar and pack it */
 444   event_viewer_data->vscroll_vc = gtk_vscrollbar_new(NULL);
 445   gtk_range_set_update_policy (GTK_RANGE(event_viewer_data->vscroll_vc),
 446              GTK_UPDATE_CONTINUOUS);
 447              // Changed by MD : more user friendly :)
 448              //GTK_UPDATE_DISCONTINUOUS);
 449   gtk_box_pack_start(GTK_BOX(event_viewer_data->hbox_v),
 450       event_viewer_data->vscroll_vc, FALSE, TRUE, 0);
 451
 452   /* Get the vertical scrollbar's adjustment */
 453   event_viewer_data->vadjust_c =
 454     gtk_range_get_adjustment(GTK_RANGE(event_viewer_data->vscroll_vc));
 455   event_viewer_data->vtree_adjust_c = gtk_tree_view_get_vadjustment(
 456                     GTK_TREE_VIEW (event_viewer_data->tree_v));
 457
 458   g_signal_connect (G_OBJECT (event_viewer_data->vadjust_c), "value-changed",
 459         G_CALLBACK (v_scroll_cb),
 460         event_viewer_data);
 461   /* Set the upper bound to the last event number */
 462   event_viewer_data->previous_value = 0;
 463   event_viewer_data->vadjust_c->lower = 0.0;
 464     //event_viewer_data->vadjust_c->upper = event_viewer_data->number_of_events;
 465   LttTime time = lttvwindow_get_current_time(tab);
 466   time = ltt_time_sub(time, tsc->time_span.start_time);
 467   event_viewer_data->vadjust_c->value = ltt_time_to_double(time);
 468   event_viewer_data->vadjust_c->value = 0.0;
 469   event_viewer_data->vadjust_c->step_increment = 1.0;
 470   event_viewer_data->vadjust_c->page_increment = 2.0;
 471     //  event_viewer_data->vtree_adjust_c->upper;
 472   event_viewer_data->vadjust_c->page_size = 2.0;
 473   //    event_viewer_data->vtree_adjust_c->upper;
 474   /*  Raw event trace */
 475   gtk_widget_show(GTK_WIDGET(event_viewer_data->button_filter));
 476   gtk_widget_show(event_viewer_data->toolbar);
 477   gtk_widget_show(event_viewer_data->hbox_v);
 478   gtk_widget_show(event_viewer_data->tree_v);
 479   gtk_widget_show(event_viewer_data->vscroll_vc);
 480
 481   /* Add the object's information to the module's array */
 482   g_event_viewer_data_list = g_slist_append(g_event_viewer_data_list,
 483       plugin_evd);
 484
 485   event_viewer_data->num_visible_events = 1;
 486
 487   //get the life span of the traceset and set the upper of the scroll bar
 488
 489   TimeInterval time_span = tsc->time_span;
 490   end = ltt_time_sub(time_span.end_time, time_span.start_time);
 491
 492   event_viewer_data->vadjust_c->upper =
 493               ltt_time_to_double(end);
 494
 495   /* Set the Selected Event */
 496   //  tree_v_set_cursor(event_viewer_data);
 497
 498  // event_viewer_data->current_time_updated = FALSE;
 499  //
 500   g_object_set_data_full(
 501       G_OBJECT(event_viewer_data->hbox_v),
 502       "plugin_data",
 503       plugin_evd,
 504       (GDestroyNotify)gui_events_free);
 505
 506   g_object_set_data(
 507       G_OBJECT(event_viewer_data->hbox_v),
 508       "event_viewer_data",
 509       event_viewer_data);
 510
 511   event_viewer_data->background_info_waiting = 0;
 512
 513
 514   request_background_data(event_viewer_data);
 515
 516   return event_viewer_data;
 517 }
 518
 519
 520
 521 static gint background_ready(void *hook_data, void *call_data)
 522 {
 523   EventViewerData *event_viewer_data = (EventViewerData *)hook_data;
 524   LttvTrace *trace = (LttvTrace*)call_data;
 525
 526   event_viewer_data->background_info_waiting--;
 527
 528   if(event_viewer_data->background_info_waiting == 0) {
 529     g_message("event viewer : background computation data ready.");
 530
 531     evd_redraw_notify(event_viewer_data, NULL);
 532   }
 533
 534   return 0;
 535 }
 536
 537
 538 static void request_background_data(EventViewerData *event_viewer_data)
 539 {
 540   LttvTracesetContext * tsc =
 541         lttvwindow_get_traceset_context(event_viewer_data->tab);
 542   gint num_traces = lttv_traceset_number(tsc->ts);
 543   gint i;
 544   LttvTrace *trace;
 545   LttvTraceState *tstate;
 546
 547   LttvHooks *background_ready_hook =
 548     lttv_hooks_new();
 549   lttv_hooks_add(background_ready_hook, background_ready, event_viewer_data,
 550       LTTV_PRIO_DEFAULT);
 551   event_viewer_data->background_info_waiting = 0;
 552
 553   for(i=0;i<num_traces;i++) {
 554     trace = lttv_traceset_get(tsc->ts, i);
 555     tstate = LTTV_TRACE_STATE(tsc->traces[i]);
 556
 557     if(lttvwindowtraces_get_ready(g_quark_from_string("state"),trace)==FALSE
 558         && !tstate->has_precomputed_states) {
 559
 560       if(lttvwindowtraces_get_in_progress(g_quark_from_string("state"),
 561                                           trace) == FALSE) {
 562         /* We first remove requests that could have been done for the same
 563          * information. Happens when two viewers ask for it before servicing
 564          * starts.
 565          */
 566         if(!lttvwindowtraces_background_request_find(trace, "state"))
 567           lttvwindowtraces_background_request_queue(
 568               main_window_get_widget(event_viewer_data->tab), trace, "state");
 569         lttvwindowtraces_background_notify_queue(event_viewer_data,
 570                                                  trace,
 571                                                  ltt_time_infinite,
 572                                                  NULL,
 573                                                  background_ready_hook);
 574         event_viewer_data->background_info_waiting++;
 575       } else { /* in progress */
 576
 577         lttvwindowtraces_background_notify_current(event_viewer_data,
 578                                                    trace,
 579                                                    ltt_time_infinite,
 580                                                    NULL,
 581                                                    background_ready_hook);
 582         event_viewer_data->background_info_waiting++;
 583       }
 584     } else {
 585       /* Data ready. By its nature, this viewer doesn't need to have
 586        * its data ready hook called there, because a background
 587        * request is always linked with a redraw.
 588        */
 589     }
 590
 591   }
 592
 593   lttv_hooks_destroy(background_ready_hook);
 594
 595 }
 596
 597 static gboolean
 598 header_size_allocate(GtkWidget *widget,
 599                         GtkAllocation *allocation,
 600                         gpointer user_data)
 601 {
 602   EventViewerData *event_viewer_data = (EventViewerData*)user_data;
 603
 604   event_viewer_data->header_height = allocation->height;
 605
 606   return 0;
 607 }
 608
 609
 610 void tree_v_set_cursor(EventViewerData *event_viewer_data)
 611 {
 612   GtkTreePath *path;
 613
 614   g_debug("set cursor cb");
 615
 616 #if 0
 617   if(event_viewer_data->currently_selected_event != -1)
 618     {
 619       path = gtk_tree_path_new_from_indices(
 620               event_viewer_data->currently_selected_event,
 621               -1);
 622
 623       gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 624           path, NULL, FALSE);
 625       gtk_tree_path_free(path);
 626     }
 627 #endif //0
 628 }
 629
 630 void tree_v_get_cursor(EventViewerData *event_viewer_data)
 631 {
 632   GtkTreePath *path;
 633   gint *indices;
 634
 635   g_debug("get cursor cb");
 636
 637
 638 #if 0
 639   gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 640       &path, NULL);
 641   indices = gtk_tree_path_get_indices(path);
 642
 643   if(indices != NULL)
 644       event_viewer_data->currently_selected_event = indices[0];
 645     else
 646       event_viewer_data->currently_selected_event = -1;
 647
 648   gtk_tree_path_free(path);
 649 #endif //0
 650 }
 651
 652 /* Filter out the key repeats that come too fast */
 653 static gboolean key_handler(GtkWidget *widget, GdkEventKey *event,
 654     gpointer user_data)
 655 {
 656   EventViewerData *evd = (EventViewerData *)user_data;
 657
 658   g_debug("event time : %u , last time : %u", event->time,
 659       evd->last_tree_update_time);
 660
 661   if(guint32_before(event->time, evd->last_tree_update_time))
 662     return TRUE;
 663   else
 664     return FALSE;
 665 }
 666
 667 void tree_v_move_cursor_cb (GtkWidget *widget,
 668                             GtkMovementStep arg1,
 669                             gint arg2,
 670                             gpointer data)
 671 {
 672   GtkTreePath *path; // = gtk_tree_path_new();
 673   gint *indices;
 674   gdouble value;
 675   EventViewerData *event_viewer_data = (EventViewerData*)data;
 676
 677   g_debug("move cursor cb");
 678   //gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 679   //                          &path, NULL);
 680   //if(path == NULL)
 681   //{
 682     /* No prior cursor, put it at beginning of page
 683      * and let the execution do */
 684   //  path = gtk_tree_path_new_from_indices(0, -1);
 685   //  gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 686   //                              path, NULL, FALSE);
 687   //}
 688
 689   //indices = gtk_tree_path_get_indices(path);
 690
 691   //value = gtk_adjustment_get_value(event_viewer_data->vadjust_c);
 692
 693   /* If events request pending, do nothing*/
 694   if(lttvwindow_events_request_pending(event_viewer_data->tab)) return;
 695
 696   /* If no prior position... */
 697 #if 0
 698   if(ltt_time_compare(
 699         lttv_traceset_context_position_get_time(
 700           event_viewer_data->currently_selected_position),
 701         ltt_time_infinite) == 0) {
 702
 703     path = gtk_tree_path_new_from_indices(0, -1);
 704     gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 705                                 path, NULL, FALSE);
 706
 707     gtk_tree_path_free(path);
 708     return;
 709
 710   }
 711 #endif //0
 712
 713   g_debug("tree view move cursor : arg1 is %u and arg2 is %d",
 714       (guint)arg1, arg2);
 715
 716   switch(arg1) {
 717   case GTK_MOVEMENT_DISPLAY_LINES:
 718     if(arg2 == 1) {
 719       /* Move one line down */
 720       if(event_viewer_data->pos->len > 0) {
 721         LttvTracesetContextPosition *end_pos =
 722           (LttvTracesetContextPosition*)g_ptr_array_index(
 723                                              event_viewer_data->pos,
 724                                              event_viewer_data->pos->len-1);
 725         if(lttv_traceset_context_pos_pos_compare(end_pos,
 726               event_viewer_data->currently_selected_position) == 0) {
 727           /* Must get down one event and select the last one */
 728           gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
 729                 GTK_TREE_VIEW(event_viewer_data->tree_v)));
 730                                         event_viewer_data->update_cursor = FALSE;
 731                                         gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 732                                                         gtk_adjustment_get_value(event_viewer_data->vadjust_c) + 1);
 733                                         event_viewer_data->update_cursor = TRUE;
 734                                         if(event_viewer_data->pos->len > 0) {
 735                                                 path = gtk_tree_path_new_from_indices(
 736                                                                 max(0, event_viewer_data->pos->len - 1), -1);
 737                                                 if(path) {
 738                                                         gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 739                                                                                                                                                          path, NULL, FALSE);
 740                                                         gtk_tree_path_free(path);
 741                                                 }
 742                                         }
 743                                 }
 744                         } else {
 745                                 /* Must get down one event and select the last one */
 746                                 gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
 747                                                         GTK_TREE_VIEW(event_viewer_data->tree_v)));
 748                                 event_viewer_data->update_cursor = FALSE;
 749                                 gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 750                                                 gtk_adjustment_get_value(event_viewer_data->vadjust_c) + 1);
 751                                 event_viewer_data->update_cursor = TRUE;
 752                                 if(event_viewer_data->pos->len > 0) {
 753                                         path = gtk_tree_path_new_from_indices(
 754                                                         max(0, event_viewer_data->pos->len - 1), -1);
 755                                         if(path) {
 756                                                 gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 757                                                                                                                                                  path, NULL, FALSE);
 758                                                 gtk_tree_path_free(path);
 759                                         }
 760                                 }
 761                         }
 762
 763     } else {
 764       if(event_viewer_data->pos->len > 0) {
 765         /* Move one line up */
 766         LttvTracesetContextPosition *begin_pos =
 767           (LttvTracesetContextPosition*)g_ptr_array_index(
 768                                              event_viewer_data->pos,
 769                                              0);
 770         if(lttv_traceset_context_pos_pos_compare(begin_pos,
 771               event_viewer_data->currently_selected_position) == 0) {
 772           /* Must get up one event and select the first one */
 773           gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
 774                 GTK_TREE_VIEW(event_viewer_data->tree_v)));
 775                                         event_viewer_data->update_cursor = FALSE;
 776                                         gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 777                                                         gtk_adjustment_get_value(event_viewer_data->vadjust_c) - 1);
 778                                         event_viewer_data->update_cursor = TRUE;
 779                                         if(event_viewer_data->pos->len > 0) {
 780                                                 path = gtk_tree_path_new_from_indices(
 781                                                                 0, -1);
 782                                                 if(path) {
 783                                                         gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 784                                                                                                                                                          path, NULL, FALSE);
 785                                                         gtk_tree_path_free(path);
 786                                                 }
 787                                         }
 788                                 }
 789                         } else {
 790                                 /* Must get up one event and select the first one */
 791                                 gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
 792                                                         GTK_TREE_VIEW(event_viewer_data->tree_v)));
 793                                 event_viewer_data->update_cursor = FALSE;
 794                                 gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 795                                                 gtk_adjustment_get_value(event_viewer_data->vadjust_c) - 1);
 796                                 event_viewer_data->update_cursor = TRUE;
 797                                 if(event_viewer_data->pos->len > 0) {
 798                                         path = gtk_tree_path_new_from_indices(
 799                                                         0, -1);
 800                                         if(path) {
 801                                                 gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 802                                                                                                                                                  path, NULL, FALSE);
 803                                                 gtk_tree_path_free(path);
 804                                         }
 805                                 }
 806                         }
 807     }
 808     break;
 809   case GTK_MOVEMENT_PAGES:
 810     if(arg2 == 1) {
 811       /* Move one page down */
 812       if(event_viewer_data->pos->len > 0) {
 813         LttvTracesetContextPosition *end_pos =
 814           (LttvTracesetContextPosition*)g_ptr_array_index(
 815                                              event_viewer_data->pos,
 816                                              event_viewer_data->pos->len-1);
 817         if(lttv_traceset_context_pos_pos_compare(end_pos,
 818               event_viewer_data->currently_selected_position) == 0) {
 819           /* Must get down one page and select the last one */
 820           gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
 821                 GTK_TREE_VIEW(event_viewer_data->tree_v)));
 822                                         event_viewer_data->update_cursor = FALSE;
 823                                         gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 824                                                         gtk_adjustment_get_value(event_viewer_data->vadjust_c) + 2);
 825                                         event_viewer_data->update_cursor = TRUE;
 826                                         if(event_viewer_data->pos->len > 0) {
 827                                                 path = gtk_tree_path_new_from_indices(
 828                                                                 event_viewer_data->pos->len - 1, -1);
 829                                                 if(path) {
 830                                                         gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 831                                                                                                                                                          path, NULL, FALSE);
 832                                                         gtk_tree_path_free(path);
 833                                                 }
 834                                         }
 835                                 }
 836                         } else {
 837                         /* Must get down one page and select the last one */
 838                                 gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
 839                                                         GTK_TREE_VIEW(event_viewer_data->tree_v)));
 840                                 event_viewer_data->update_cursor = FALSE;
 841                                 gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 842                                                 gtk_adjustment_get_value(event_viewer_data->vadjust_c) + 2);
 843                                 event_viewer_data->update_cursor = TRUE;
 844                                 if(event_viewer_data->pos->len > 0) {
 845                                         path = gtk_tree_path_new_from_indices(
 846                                                         event_viewer_data->pos->len - 1, -1);
 847                                         if(path) {
 848                                                 gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 849                                                                                                                                                  path, NULL, FALSE);
 850                                                 gtk_tree_path_free(path);
 851                                         }
 852                                 }
 853                         }
 854     } else {
 855       /* Move one page up */
 856       if(event_viewer_data->pos->len > 0) {
 857         LttvTracesetContextPosition *begin_pos =
 858           (LttvTracesetContextPosition*)g_ptr_array_index(
 859                                              event_viewer_data->pos,
 860                                              0);
 861         if(lttv_traceset_context_pos_pos_compare(begin_pos,
 862               event_viewer_data->currently_selected_position) == 0) {
 863           /* Must get up one page and select the first one */
 864           gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
 865                 GTK_TREE_VIEW(event_viewer_data->tree_v)));
 866                                         event_viewer_data->update_cursor = FALSE;
 867                                         gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 868                                                         gtk_adjustment_get_value(event_viewer_data->vadjust_c) - 2);
 869                                         event_viewer_data->update_cursor = TRUE;
 870                                         if(event_viewer_data->pos->len > 0) {
 871                                                 path = gtk_tree_path_new_from_indices(
 872                                                                 0, -1);
 873                                                 if(path) {
 874                                                         gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 875                                                                                                                                                          path, NULL, FALSE);
 876                                                         gtk_tree_path_free(path);
 877                                                 }
 878                                         }
 879                                 }
 880                         }       else {
 881                                 /* Must get up one page and select the first one */
 882                                 gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
 883                                                         GTK_TREE_VIEW(event_viewer_data->tree_v)));
 884                                 event_viewer_data->update_cursor = FALSE;
 885                                 gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 886                                                 gtk_adjustment_get_value(event_viewer_data->vadjust_c) - 2);
 887                                 event_viewer_data->update_cursor = TRUE;
 888                                 if(event_viewer_data->pos->len > 0) {
 889                                         path = gtk_tree_path_new_from_indices(
 890                                                         0, -1);
 891                                         if(path) {
 892                                                 gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 893                                                                                                                                                  path, NULL, FALSE);
 894                                                 gtk_tree_path_free(path);
 895                                         }
 896                                 }
 897                         }
 898     }
 899     break;
 900   default:
 901     break;
 902   }
 903
 904   //gtk_tree_path_free(path);
 905
 906 #if 0
 907   if(arg1 == GTK_MOVEMENT_DISPLAY_LINES)
 908   {
 909     /* Move one line */
 910     if(arg2 == 1)
 911     {
 912       /* move one line down */
 913       if(indices[0]) // Do we need an empty field here (before first)?
 914       {
 915         if(value + event_viewer_data->num_visible_events <=
 916             event_viewer_data->number_of_events -1)
 917         {
 918           event_viewer_data->currently_selected_event += 1;
 919           //      gtk_adjustment_set_value(event_viewer_data->vadjust_c, value+1);
 920           //gtk_tree_path_free(path);
 921           //path = gtk_tree_path_new_from_indices(event_viewer_data->num_visible_events-1, -1);
 922           //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 923           g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 924         }
 925       }
 926     } else {
 927       /* Move one line up */
 928       if(indices[0] == 0)
 929       {
 930         if(value - 1 >= 0 )
 931         {
 932           event_viewer_data->currently_selected_event -= 1;
 933           //      gtk_adjustment_set_value(event_viewer_data->vadjust_c, value-1);
 934           //gtk_tree_path_free(path);
 935           //path = gtk_tree_path_new_from_indices(0, -1);
 936           //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 937           g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 938         }
 939       }
 940     }
 941   }
 942
 943   if(arg1 == GTK_MOVEMENT_PAGES)
 944   {
 945     /* Move one page */
 946     if(arg2 == 1)
 947     {
 948       if(event_viewer_data->num_visible_events == 1)
 949         value += 1 ;
 950       /* move one page down */
 951       if(value + event_viewer_data->num_visible_events-1 <=
 952                       event_viewer_data->number_of_events )
 953       {
 954         event_viewer_data->currently_selected_event +=
 955                                   event_viewer_data->num_visible_events-1;
 956         //        gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 957         //               value+(event_viewer_data->num_visible_events-1));
 958         //gtk_tree_path_free(path);
 959         //path = gtk_tree_path_new_from_indices(0, -1);
 960         //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 961         g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 962       }
 963     } else {
 964       /* Move one page up */
 965       if(event_viewer_data->num_visible_events == 1)
 966         value -= 1 ;
 967
 968       if(indices[0] < event_viewer_data->num_visible_events - 2 )
 969       {
 970         if(value - (event_viewer_data->num_visible_events-1) >= 0)
 971         {
 972           event_viewer_data->currently_selected_event -=
 973                           event_viewer_data->num_visible_events-1;
 974
 975           //      gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 976           //             value-(event_viewer_data->num_visible_events-1));
 977           //gtk_tree_path_free(path);
 978           //path = gtk_tree_path_new_from_indices(0, -1);
 979           //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 980           g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 981
 982         } else {
 983           /* Go to first Event */
 984           event_viewer_data->currently_selected_event == 0 ;
 985           //      gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 986           //             0);
 987           //gtk_tree_path_free(path);
 988           //path = gtk_tree_path_new_from_indices(0, -1);
 989           //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 990           g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 991
 992         }
 993       }
 994     }
 995   }
 996
 997   if(arg1 == GTK_MOVEMENT_BUFFER_ENDS)
 998   {
 999     /* Move to the ends of the buffer */
1000     if(arg2 == 1)
1001     {
1002       /* move end of buffer */
1003       event_viewer_data->currently_selected_event =
1004                             event_viewer_data->number_of_events-1 ;
1005       //    gtk_adjustment_set_value(event_viewer_data->vadjust_c,
1006       //           event_viewer_data->number_of_events -
1007       //           event_viewer_data->num_visible_events);
1008       //gtk_tree_path_free(path);
1009       //path = gtk_tree_path_new_from_indices(event_viewer_data->num_visible_events-1, -1);
1010       //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
1011       g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
1012     } else {
1013       /* Move beginning of buffer */
1014       event_viewer_data->currently_selected_event = 0 ;
1015       //    gtk_adjustment_set_value(event_viewer_data->vadjust_c, 0);
1016         //gtk_tree_path_free(path);
1017         //path = gtk_tree_path_new_from_indices(0, -1);
1018         //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
1019       g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
1020     }
1021   }
1022 #endif //0
1023 }
1024
1025 static void        filter_button      (GtkToolButton *toolbutton,
1026                                           gpointer       user_data)
1027 {
1028   LttvPluginEVD *plugin_evd = (LttvPluginEVD*)user_data;
1029   LttvAttribute *attribute;
1030   LttvAttributeValue value;
1031   gboolean ret;
1032   g_printf("Filter button clicked\n");
1033
1034   attribute = LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
1035         LTTV_IATTRIBUTE(lttv_global_attributes()),
1036         LTTV_VIEWER_CONSTRUCTORS));
1037   g_assert(attribute);
1038
1039   ret = lttv_iattribute_find_by_path(LTTV_IATTRIBUTE(attribute),
1040       "guifilter", LTTV_POINTER, &value);
1041   g_assert(ret);
1042   lttvwindow_viewer_constructor constructor =
1043     (lttvwindow_viewer_constructor)*(value.v_pointer);
1044   if(constructor) constructor(&plugin_evd->parent);
1045   else g_warning("Filter module not loaded.");
1046
1047   //FIXME : viewer returned.
1048 }
1049
1050 gboolean tree_v_scroll_handler (GtkWidget *widget, GdkEventScroll *event, gpointer data)
1051 {
1052         EventViewerData *event_viewer_data = (EventViewerData*) data;
1053         Tab *tab = event_viewer_data->tab;
1054
1055         switch(event->direction) {
1056                 case GDK_SCROLL_UP:
1057                         gtk_adjustment_set_value(event_viewer_data->vadjust_c,
1058                                 gtk_adjustment_get_value(event_viewer_data->vadjust_c) - 1);
1059                         break;
1060                 case GDK_SCROLL_DOWN:
1061                         gtk_adjustment_set_value(event_viewer_data->vadjust_c,
1062                                 gtk_adjustment_get_value(event_viewer_data->vadjust_c) + 1);
1063                         break;
1064                 default:
1065                         g_error("Only scroll up and down expected");
1066         }
1067         return TRUE;
1068 }
1069
1070 void tree_v_cursor_changed_cb (GtkWidget *widget, gpointer data)
1071 {
1072   EventViewerData *event_viewer_data = (EventViewerData*) data;
1073   Tab *tab = event_viewer_data->tab;
1074   GtkTreeIter iter;
1075   GtkTreeModel* model = GTK_TREE_MODEL(event_viewer_data->store_m);
1076   GtkTreePath *path;
1077   LttvTracesetContextPosition *pos;
1078
1079   g_debug("cursor changed cb");
1080
1081   /* On cursor change, modify the currently selected event by calling
1082    * the right API function */
1083   if(event_viewer_data->report_position) {
1084     if(event_viewer_data->pos->len > 0) {
1085                         gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
1086                                         &path, NULL);
1087                         if(path) {
1088                                 if(gtk_tree_model_get_iter(model,&iter,path)){
1089                                         gtk_tree_model_get(model, &iter, POSITION_COLUMN, &pos, -1);
1090
1091                                         if(lttv_traceset_context_pos_pos_compare(pos,
1092                                                                 event_viewer_data->currently_selected_position) != 0)
1093                                                 lttvwindow_report_current_position(tab, pos);
1094                                 }else{
1095                                         g_warning("Can not get iter\n");
1096                                 }
1097                                 gtk_tree_path_free(path);
1098                         }
1099                 }
1100         }
1101 }
1102
1103
1104 static void tree_selection_changed_cb (GtkTreeSelection *selection,
1105     gpointer data)
1106 {
1107   g_debug("tree sel changed cb");
1108   EventViewerData *event_viewer_data = (EventViewerData*) data;
1109
1110 #if 0
1111     /* Set the cursor to currently selected event */
1112   GtkTreeModel* model = GTK_TREE_MODEL(event_viewer_data->store_m);
1113   GtkTreeIter iter;
1114   LttvTracesetContextPosition *pos;
1115   guint i;
1116   GtkTreePath *tree_path;
1117
1118   for(i=0;i<event_viewer_data->num_visible_events;i++) {
1119     tree_path = gtk_tree_path_new_from_indices(
1120                 i,
1121                -1);
1122     if(gtk_tree_model_get_iter(model,&iter,tree_path)){
1123       gtk_tree_model_get(model, &iter, POSITION_COLUMN, &pos, -1);
1124
1125       if(lttv_traceset_context_pos_pos_compare(pos,
1126             event_viewer_data->currently_selected_position) == 0) {
1127         /* Match! */
1128             gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
1129                 tree_path, NULL, FALSE);
1130         break;
1131       }
1132
1133     }else{
1134       g_warning("Can not get iter\n");
1135     }
1136    gtk_tree_path_free(tree_path);
1137   }
1138 #endif //0
1139 }
1140
1141 #if 0
1142 static gint key_snooper(GtkWidget *grab_widget, GdkEventKey *event,
1143     gpointer func_data)
1144 {
1145   return TRUE;
1146 }
1147 #endif //0
1148
1149 /* This callback may be recalled after a step up/down, but we don't want to lose
1150  * the exact position : what we do is that we only set the value if it has
1151  * changed : a step up/down that doesn't change the time value of the first
1152  * event won't trigger a scrollbar change. */
1153
1154 void v_scroll_cb (GtkAdjustment *adjustment, gpointer data)
1155 {
1156   EventViewerData *event_viewer_data = (EventViewerData*)data;
1157   LttvTracesetStats *tss =
1158     lttvwindow_get_traceset_stats(event_viewer_data->tab);
1159   LttvTracesetContext *tsc = (LttvTracesetContext*)tss;
1160   g_debug("SCROLL begin");
1161   g_debug("SCROLL values : %g , %g, %g",
1162       adjustment->value, event_viewer_data->previous_value,
1163       (adjustment->value - event_viewer_data->previous_value));
1164
1165   LttTime new_time_off = ltt_time_from_double(adjustment->value);
1166   LttTime old_time_off = ltt_time_from_double(event_viewer_data->previous_value);
1167   g_debug("SCROLL time values %lu.%lu, %lu.%lu", new_time_off.tv_sec,
1168       new_time_off.tv_nsec, old_time_off.tv_sec, old_time_off.tv_nsec);
1169   /* If same value : nothing to update */
1170   if(ltt_time_compare(new_time_off, old_time_off) == 0)
1171     return;
1172
1173   //LttTime old_time = event_viewer_data->first_event;
1174
1175
1176   //gint snoop = gtk_key_snooper_install(key_snooper, NULL);
1177
1178   get_events(adjustment->value, event_viewer_data);
1179
1180   //gtk_key_snooper_remove(snoop);
1181 #if 0
1182   LttTime time = ltt_time_sub(event_viewer_data->first_event,
1183                               tsc->time_span.start_time);
1184   double value = ltt_time_to_double(time);
1185   gtk_adjustment_set_value(event_viewer_data->vadjust_c, value);
1186
1187   if(event_viewer_data->currently_selected_event != -1) {
1188
1189       tree_path = gtk_tree_path_new_from_indices(
1190              event_viewer_data->currently_selected_event,
1191              -1);
1192
1193       //      gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), tree_path,
1194       //             NULL, FALSE);
1195       gtk_tree_path_free(tree_path);
1196   }
1197 #endif //0
1198   g_debug("SCROLL end");
1199 }
1200
1201 static __inline gint get_cell_height(GtkTreeView *TreeView)
1202 {
1203   gint height;
1204   GtkTreeViewColumn *column = gtk_tree_view_get_column(TreeView, 0);
1205
1206   gtk_tree_view_column_cell_get_size(column, NULL, NULL, NULL, NULL, &height);
1207
1208   gint vertical_separator;
1209   gtk_widget_style_get (GTK_WIDGET (TreeView),
1210       "vertical-separator", &vertical_separator,
1211       NULL);
1212
1213         height += vertical_separator;
1214
1215   return height;
1216 }
1217
1218 void tree_v_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data)
1219 {
1220   EventViewerData *event_viewer_data = (EventViewerData*)data;
1221   gint cell_height = get_cell_height(GTK_TREE_VIEW(event_viewer_data->tree_v));
1222   gint last_num_visible_events = event_viewer_data->num_visible_events;
1223   gdouble exact_num_visible;
1224
1225   exact_num_visible = ( alloc->height -
1226           event_viewer_data->header_height )
1227             / (double)cell_height ;
1228
1229   event_viewer_data->num_visible_events = ceil(exact_num_visible) ;
1230
1231 /*
1232   event_viewer_data->vadjust_c->page_increment =
1233     floor(exact_num_visible);
1234   event_viewer_data->vadjust_c->page_size =
1235     floor(exact_num_visible);
1236 */
1237
1238   g_debug("size allocate %p : last_num_visible_events : %d",
1239            event_viewer_data, last_num_visible_events);
1240   g_debug("num_visible_events : %d, value %lu",
1241            event_viewer_data->num_visible_events,
1242            event_viewer_data->vadjust_c->value);
1243
1244   if(event_viewer_data->num_visible_events != last_num_visible_events) {
1245       get_events(event_viewer_data->vadjust_c->value, event_viewer_data);
1246   }
1247
1248
1249 }
1250
1251 void tree_v_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data)
1252 {
1253   gint h;
1254   EventViewerData *event_viewer_data = (EventViewerData*)data;
1255   gint cell_height = get_cell_height(GTK_TREE_VIEW(event_viewer_data->tree_v));
1256
1257   h = cell_height + event_viewer_data->header_height;
1258   requisition->height = h;
1259
1260 }
1261
1262 #if 0
1263 gboolean show_event_detail(void * hook_data, void * call_data)
1264 {
1265   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1266   LttvTracesetContext * tsc = lttvwindow_get_traceset_context(event_viewer_data->tab);
1267
1268   if(event_viewer_data->event_fields_queue_tmp->length == 0 &&
1269      event_viewer_data->event_fields_queue->length == 0){
1270     event_viewer_data->shown = FALSE;
1271     return FALSE;
1272   }
1273
1274   if(event_viewer_data->shown == FALSE){
1275     event_viewer_data->shown = TRUE;
1276     update_raw_data_array(event_viewer_data,
1277         event_viewer_data->event_fields_queue_tmp->length);
1278
1279     get_data(event_viewer_data->vadjust_c->value,
1280       event_viewer_data->num_visible_events,
1281       event_viewer_data);
1282
1283     remove_context_hooks(event_viewer_data,tsc);
1284   }
1285
1286   return FALSE;
1287 }
1288 #endif //0
1289
1290 static gboolean events_check_handler(guint count, gboolean *stop_flag,
1291   gpointer data)
1292 {
1293   EventViewerData *evd = (EventViewerData*)data;
1294   if(count % CHECK_GDK_INTERVAL == 0) {
1295     GdkEvent *event;
1296     GtkWidget *widget;
1297     while((event = gdk_event_get()) != NULL) {
1298         widget = gtk_get_event_widget(event);
1299         if(widget ==
1300           lookup_widget(main_window_get_widget(evd->tab),
1301               "StopProcessingButton")
1302           || widget == evd->vscroll_vc) {
1303           gtk_main_do_event(event);
1304           gdk_window_process_all_updates();
1305         }
1306         gdk_event_free(event);
1307     }
1308     if(*stop_flag)
1309       return TRUE;
1310     else
1311       return FALSE;
1312   } else return FALSE;
1313 }
1314
1315 static void get_events(double new_value, EventViewerData *event_viewer_data)
1316 {
1317   GtkTreePath *tree_path;
1318   LttvTracesetStats *tss =
1319     lttvwindow_get_traceset_stats(event_viewer_data->tab);
1320   LttvTracesetContext *tsc = (LttvTracesetContext*)tss;
1321   guint i;
1322   gboolean seek_by_time;
1323
1324   if(lttvwindow_preempt_count > 0) return;
1325
1326   double value = new_value - event_viewer_data->previous_value;
1327
1328   /* Set stop button status for foreground processing */
1329   event_viewer_data->tab->stop_foreground = FALSE;
1330   lttvwindow_events_request_disable();
1331
1332   /* See where we have to scroll... */
1333   ScrollDirection direction;
1334   gint relative_position;
1335
1336   if(value < -0.8) {
1337     if(value >= -1.0) direction = SCROLL_STEP_UP;
1338     else {
1339       if(value >= -2.0) direction = SCROLL_PAGE_UP;
1340       else direction = SCROLL_JUMP;
1341     }
1342   } else if(value > 0.8) {
1343     if(value <= 1.0) direction = SCROLL_STEP_DOWN;
1344     else {
1345       if(value <= 2.0) direction = SCROLL_PAGE_DOWN;
1346       else direction = SCROLL_JUMP;
1347     }
1348   } else direction = SCROLL_NONE; /* 0.0 */
1349
1350
1351   switch(direction) {
1352   case SCROLL_STEP_UP:
1353     g_debug("get_events : SCROLL_STEP_UP");
1354     relative_position = -1;
1355     seek_by_time = 0;
1356     break;
1357   case SCROLL_STEP_DOWN:
1358     g_debug("get_events : SCROLL_STEP_DOWN");
1359     relative_position = 1;
1360     seek_by_time = 0;
1361     break;
1362   case SCROLL_PAGE_UP:
1363     g_debug("get_events : SCROLL_PAGE_UP");
1364     relative_position = -(event_viewer_data->num_visible_events);
1365     seek_by_time = 0;
1366     break;
1367   case SCROLL_PAGE_DOWN:
1368     g_debug("get_events : SCROLL_PAGE_DOWN");
1369     relative_position = event_viewer_data->num_visible_events;
1370     seek_by_time = 0;
1371     break;
1372   case SCROLL_JUMP:
1373     g_debug("get_events : SCROLL_JUMP");
1374     seek_by_time = 1;
1375     break;
1376   case SCROLL_NONE:
1377     g_debug("get_events : SCROLL_NONE");
1378     relative_position = 0;
1379     seek_by_time = 0;
1380     break;
1381   }
1382
1383   LttTime time = ltt_time_from_double(new_value);
1384   time = ltt_time_add(tsc->time_span.start_time, time);
1385
1386   if(!seek_by_time) {
1387
1388     LttvTracesetContextPosition *pos =
1389         lttv_traceset_context_position_new(tsc);
1390
1391     /* Remember the beginning position */
1392     if(event_viewer_data->pos->len > 0) {
1393       LttvTracesetContextPosition *first_pos =
1394         (LttvTracesetContextPosition*)g_ptr_array_index(
1395                                                     event_viewer_data->pos,
1396                                                     0);
1397       lttv_traceset_context_position_copy(pos, first_pos);
1398
1399       if(relative_position >= 0) {
1400         LttTime first_event_time =
1401             lttv_traceset_context_position_get_time(
1402                               pos);
1403         lttv_state_traceset_seek_time_closest((LttvTracesetState*)tsc,
1404           first_event_time);
1405         lttv_process_traceset_middle(tsc, ltt_time_infinite,
1406                                    G_MAXUINT,
1407                                    pos);
1408
1409       } else if(relative_position < 0) {
1410         g_assert(lttv_process_traceset_seek_position(tsc, pos) == 0);
1411       }
1412     } else {
1413       /* There is nothing in the list : simply seek to the time value. */
1414       lttv_state_traceset_seek_time_closest((LttvTracesetState*)tsc,
1415           time);
1416       lttv_process_traceset_middle(tsc, time, G_MAXUINT,
1417                                    NULL);
1418     }
1419
1420   /* Note that, as we mess with the tsc position, this function CANNOT be called
1421    * from a hook inside the lttv_process_traceset_middle. */
1422   /* As the lttvwindow API keeps a sync_position inside the tsc to go back at
1423    * the right spot after being interrupted, it's ok to change the tsc position,
1424    * as long as we do not touch the sync_position. */
1425
1426   /* Get the beginning position of the read (with seek backward or seek forward)
1427    */
1428     if(relative_position > 0) {
1429       guint count;
1430       count += lttv_process_traceset_seek_n_forward(tsc, relative_position,
1431           events_check_handler,
1432           &event_viewer_data->tab->stop_foreground,
1433           event_viewer_data->main_win_filter,
1434           event_viewer_data->filter, NULL, event_viewer_data);
1435     } else if(relative_position < 0) {
1436       guint count;
1437
1438       /* Get an idea of currently shown event dispersion */
1439       LttTime first_event_time =
1440         lttv_traceset_context_position_get_time(event_viewer_data->first_event);
1441       LttTime last_event_time =
1442         lttv_traceset_context_position_get_time(event_viewer_data->last_event);
1443       LttTime time_diff = ltt_time_sub(last_event_time, first_event_time);
1444       if(ltt_time_compare(time_diff, ltt_time_zero) == 0)
1445         time_diff = seek_back_default_offset;
1446
1447       count = lttv_process_traceset_seek_n_backward(tsc,
1448           abs(relative_position),
1449           time_diff,
1450           (seek_time_fct)lttv_state_traceset_seek_time_closest,
1451           events_check_handler,
1452           &event_viewer_data->tab->stop_foreground,
1453           event_viewer_data->main_win_filter,
1454           event_viewer_data->filter, NULL, event_viewer_data);
1455     } /* else 0 : do nothing : we are already at the beginning position */
1456
1457     lttv_traceset_context_position_destroy(pos);
1458
1459     /* Save the first event position */
1460     lttv_traceset_context_position_save(tsc, event_viewer_data->first_event);
1461
1462     time = lttv_traceset_context_position_get_time(
1463                                             event_viewer_data->first_event);
1464     //if(ltt_time_compare(time, tsc->time_span.end_time) > 0)
1465     //  time = tsc->time_span.end_time;
1466
1467     LttTime time_val = ltt_time_sub(time,
1468                         tsc->time_span.start_time);
1469     event_viewer_data->previous_value = ltt_time_to_double(time_val);
1470
1471     lttv_state_traceset_seek_time_closest((LttvTracesetState*)tsc, time);
1472     lttv_process_traceset_middle(tsc, ltt_time_infinite, G_MAXUINT,
1473                                  event_viewer_data->first_event);
1474
1475   } else {
1476     /* Seek by time */
1477     lttv_state_traceset_seek_time_closest((LttvTracesetState*)tsc,
1478           time);
1479     lttv_process_traceset_middle(tsc, time, G_MAXUINT,
1480                                  NULL);
1481     LttTime time_val = ltt_time_sub(time,
1482                         tsc->time_span.start_time);
1483     event_viewer_data->previous_value = ltt_time_to_double(time_val);
1484     lttv_traceset_context_position_save(tsc, event_viewer_data->first_event);
1485   }
1486
1487   /* Clear the model (don't forget to free the TCS positions!) */
1488   gtk_list_store_clear(event_viewer_data->store_m);
1489   for(i=0;i<event_viewer_data->pos->len;i++) {
1490     LttvTracesetContextPosition *cur_pos =
1491       (LttvTracesetContextPosition*)g_ptr_array_index(event_viewer_data->pos,
1492                                                       i);
1493     lttv_traceset_context_position_destroy(cur_pos);
1494   }
1495   g_ptr_array_set_size(event_viewer_data->pos, 0);
1496
1497
1498   /* Mathieu :
1499    * I make the choice not to use the mainwindow lttvwindow API here : the idle
1500    * loop might have a too low priority, and we want good update while
1501    * scrolling. However, we call the gdk loop to get events periodically so the
1502    * processing can be stopped.
1503    */
1504
1505   lttv_process_traceset_begin(tsc,
1506       NULL, NULL, NULL, event_viewer_data->event_hooks, NULL);
1507
1508   event_viewer_data->num_events = 0;
1509
1510   lttv_process_traceset_middle(tsc, ltt_time_infinite, G_MAXUINT, NULL);
1511
1512   lttv_process_traceset_end(tsc,
1513       NULL, NULL, NULL, event_viewer_data->event_hooks, NULL);
1514
1515   /* Get the end position */
1516   if(event_viewer_data->pos->len > 0) {
1517     LttvTracesetContextPosition *cur_pos =
1518       (LttvTracesetContextPosition*)g_ptr_array_index(event_viewer_data->pos,
1519                                                event_viewer_data->pos->len - 1);
1520     lttv_traceset_context_position_copy(event_viewer_data->last_event,
1521         cur_pos);
1522   } else
1523     lttv_traceset_context_position_save(tsc, event_viewer_data->last_event);
1524
1525   gtk_adjustment_set_value(event_viewer_data->vadjust_c,
1526       event_viewer_data->previous_value);
1527
1528   //g_signal_emit_by_name(G_OBJECT (event_viewer_data->select_c),
1529   //    "changed");
1530
1531   event_viewer_data->last_tree_update_time =
1532     gdk_x11_get_server_time(
1533         gtk_widget_get_parent_window(event_viewer_data->tree_v));
1534
1535   lttvwindow_events_request_enable();
1536
1537   return;
1538 }
1539
1540
1541 int event_hook(void *hook_data, void *call_data)
1542 {
1543   EventViewerData *event_viewer_data = (EventViewerData*)hook_data;
1544   LttvTracefileContext *tfc = (LttvTracefileContext*)call_data;
1545   LttvTracefileState *tfs = (LttvTracefileState*)call_data;
1546   LttEvent *e = ltt_tracefile_get_event(tfc->tf);
1547
1548   if(event_viewer_data->num_events % CHECK_GDK_INTERVAL == 0) {
1549     GdkEvent *event;
1550     GtkWidget *widget;
1551     while((event = gdk_event_get()) != NULL) {
1552         widget = gtk_get_event_widget(event);
1553         if(widget ==
1554           lookup_widget(main_window_get_widget(event_viewer_data->tab),
1555               "StopProcessingButton")
1556           || widget == event_viewer_data->vscroll_vc) {
1557           gtk_main_do_event(event);
1558           gdk_window_process_all_updates();
1559         }
1560         gdk_event_free(event);
1561     }
1562     //gtk_main_iteration_do(FALSE);
1563     if(event_viewer_data->tab->stop_foreground)
1564       return TRUE;
1565   }
1566   event_viewer_data->num_events++;
1567
1568   LttvFilter *filter = event_viewer_data->main_win_filter;
1569   if(filter != NULL && filter->head != NULL)
1570     if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1571           tfc->t_context->t,tfc,NULL,NULL))
1572       return FALSE;
1573
1574   filter = event_viewer_data->filter;
1575   if(filter != NULL && filter->head != NULL)
1576     if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1577           tfc->t_context->t,tfc,NULL,NULL))
1578       return FALSE;
1579
1580
1581   LttFacility *facility = ltt_event_facility(e);
1582   LttEventType *event_type = ltt_event_eventtype(e);
1583   LttTime time = ltt_event_time(e);
1584
1585   guint cpu = tfs->cpu;
1586   LttvTraceState *ts = (LttvTraceState*)tfc->t_context;
1587   LttvProcessState *process = ts->running_process[cpu];
1588
1589   GtkTreeIter iter;
1590
1591   GString *desc = g_string_new("");
1592
1593   LttvTracesetContextPosition *pos =
1594     lttv_traceset_context_position_new(tfc->t_context->ts_context);
1595
1596   lttv_traceset_context_position_save(tfc->t_context->ts_context, pos);
1597
1598   lttv_event_to_string(e, desc, TRUE, TRUE, (LttvTracefileState*)tfc);
1599
1600   g_info("detail : %s", desc->str);
1601
1602   gtk_list_store_append (event_viewer_data->store_m, &iter);
1603   gtk_list_store_set (event_viewer_data->store_m, &iter,
1604       TRACE_NAME_COLUMN, g_quark_to_string(ltt_trace_name(tfc->t_context->t)),
1605       TRACEFILE_NAME_COLUMN, g_quark_to_string(ltt_tracefile_name(tfc->tf)),
1606       CPUID_COLUMN, cpu,
1607       FACILITY_COLUMN, g_quark_to_string(ltt_facility_name(facility)),
1608       EVENT_COLUMN, g_quark_to_string(ltt_eventtype_name(event_type)),
1609       TIME_S_COLUMN, time.tv_sec,
1610       TIME_NS_COLUMN, time.tv_nsec,
1611       PID_COLUMN, process->pid,
1612       EVENT_DESCR_COLUMN, desc->str,
1613       POSITION_COLUMN, pos,
1614       -1);
1615
1616   g_ptr_array_add(event_viewer_data->pos, pos);
1617
1618   g_string_free(desc, TRUE);
1619
1620   if(event_viewer_data->update_cursor) {
1621     if(lttv_traceset_context_pos_pos_compare(pos,
1622           event_viewer_data->currently_selected_position) == 0) {
1623       GtkTreePath *path = gtk_tree_path_new_from_indices(
1624                           event_viewer_data->pos->len - 1, -1);
1625                         if(path) {
1626               gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
1627                                    path, NULL, FALSE);
1628           gtk_tree_path_free(path);
1629                         }
1630     }
1631   }
1632
1633   if(event_viewer_data->pos->len >= event_viewer_data->num_visible_events )
1634     return TRUE;
1635   else
1636     return FALSE;
1637 }
1638
1639
1640
1641 static void event_update_selection(EventViewerData *event_viewer_data)
1642 {
1643   guint i;
1644   GPtrArray *positions = event_viewer_data->pos;
1645   g_info("event_update_selection");
1646
1647   for(i=0;i<positions->len;i++) {
1648     LttvTracesetContextPosition *cur_pos =
1649       (LttvTracesetContextPosition*)g_ptr_array_index(positions, i);
1650     if(lttv_traceset_context_pos_pos_compare(cur_pos,
1651           event_viewer_data->currently_selected_position) == 0) {
1652       GtkTreePath *path = gtk_tree_path_new_from_indices(i, -1);
1653                         if(path) {
1654               gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
1655                                      path, NULL, FALSE);
1656               gtk_tree_path_free(path);
1657                         }
1658     }
1659   }
1660 }
1661
1662 static int current_time_get_first_event_hook(void *hook_data, void *call_data)
1663 {
1664   EventViewerData *event_viewer_data = (EventViewerData*)hook_data;
1665   LttvTracefileContext *tfc = (LttvTracefileContext*)call_data;
1666   LttEvent *e = ltt_tracefile_get_event(tfc->tf);
1667
1668   LttvFilter *filter = event_viewer_data->main_win_filter;
1669   if(filter != NULL && filter->head != NULL)
1670     if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1671           tfc->t_context->t,tfc,NULL,NULL))
1672       return FALSE;
1673
1674   filter = event_viewer_data->filter;
1675   if(filter != NULL && filter->head != NULL)
1676     if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1677           tfc->t_context->t,tfc,NULL,NULL))
1678       return FALSE;
1679
1680   lttv_traceset_context_position_save(tfc->t_context->ts_context,
1681       event_viewer_data->current_time_get_first);
1682   return TRUE;
1683 }
1684
1685
1686 gboolean update_current_time(void * hook_data, void * call_data)
1687 {
1688   g_info("update_current_time");
1689   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1690   const LttTime * current_time = (LttTime*)call_data;
1691   LttvTracesetContext * tsc =
1692         lttvwindow_get_traceset_context(event_viewer_data->tab);
1693   GtkTreePath *path;
1694
1695   /* If the currently selected event time != current time, set the first event
1696    * with this time as currently selected. */
1697   LttTime pos_time = lttv_traceset_context_position_get_time(
1698       event_viewer_data->currently_selected_position);
1699   if(ltt_time_compare(pos_time, *current_time) != 0) {
1700
1701     lttv_state_traceset_seek_time_closest((LttvTracesetState*)tsc,
1702         *current_time);
1703     lttv_process_traceset_middle(tsc, *current_time, G_MAXUINT,
1704                                    NULL);
1705
1706     /* Get the first event that passes in the filter */
1707     event_viewer_data->current_time_get_first =
1708                 lttv_traceset_context_position_new(tsc);
1709     LttvHooks *hooks = lttv_hooks_new();
1710     lttv_hooks_add(hooks,
1711                    current_time_get_first_event_hook,
1712                    event_viewer_data,
1713                    LTTV_PRIO_DEFAULT);
1714
1715     lttv_process_traceset_begin(tsc,
1716         NULL, NULL, NULL, hooks, NULL);
1717
1718     lttv_process_traceset_middle(tsc, ltt_time_infinite, G_MAXUINT, NULL);
1719
1720     lttv_process_traceset_end(tsc,
1721         NULL, NULL, NULL, hooks, NULL);
1722
1723     lttv_hooks_destroy(hooks);
1724
1725     lttv_traceset_context_position_copy(
1726         event_viewer_data->currently_selected_position,
1727         event_viewer_data->current_time_get_first);
1728     lttv_traceset_context_position_destroy(
1729         event_viewer_data->current_time_get_first);
1730     pos_time = lttv_traceset_context_position_get_time(
1731         event_viewer_data->currently_selected_position);
1732   }
1733
1734   LttTime time = ltt_time_sub(pos_time, tsc->time_span.start_time);
1735   double new_value = ltt_time_to_double(time);
1736
1737   event_viewer_data->report_position = FALSE;
1738   /* Change the viewed area if does not match */
1739   if(lttv_traceset_context_pos_pos_compare(
1740         event_viewer_data->currently_selected_position,
1741         event_viewer_data->first_event) < 0
1742     ||
1743      lttv_traceset_context_pos_pos_compare(
1744         event_viewer_data->currently_selected_position,
1745         event_viewer_data->last_event) > 0) {
1746     gtk_adjustment_set_value(event_viewer_data->vadjust_c, new_value);
1747   } else {
1748     /* Simply update the current time : it is in the list */
1749     event_update_selection(event_viewer_data);
1750   }
1751   event_viewer_data->report_position = TRUE;
1752
1753   return FALSE;
1754 }
1755
1756 gboolean update_current_position(void * hook_data, void * call_data)
1757 {
1758   g_info("update_current_position");
1759   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1760   const LttvTracesetContextPosition *current_pos =
1761     (LttvTracesetContextPosition*)call_data;
1762   LttvTracesetContext * tsc =
1763         lttvwindow_get_traceset_context(event_viewer_data->tab);
1764
1765   if(lttv_traceset_context_pos_pos_compare(
1766         event_viewer_data->currently_selected_position, current_pos) != 0) {
1767     lttv_traceset_context_position_copy(
1768         event_viewer_data->currently_selected_position, current_pos);
1769
1770     /* Change the viewed area if does not match */
1771     if(lttv_traceset_context_pos_pos_compare(
1772           event_viewer_data->currently_selected_position,
1773           event_viewer_data->first_event) < 0
1774       ||
1775        lttv_traceset_context_pos_pos_compare(
1776           event_viewer_data->currently_selected_position,
1777           event_viewer_data->last_event) > 0) {
1778       LttTime time = lttv_traceset_context_position_get_time(current_pos);
1779       time = ltt_time_sub(time, tsc->time_span.start_time);
1780       double new_value = ltt_time_to_double(time);
1781       gtk_adjustment_set_value(event_viewer_data->vadjust_c, new_value);
1782     } else {
1783       /* Simply update the current time : it is in the list */
1784       event_update_selection(event_viewer_data);
1785     }
1786
1787   }
1788
1789
1790   return FALSE;
1791 }
1792
1793
1794
1795 gboolean traceset_changed(void * hook_data, void * call_data)
1796 {
1797   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1798   LttvTracesetContext * tsc =
1799         lttvwindow_get_traceset_context(event_viewer_data->tab);
1800   TimeInterval time_span = tsc->time_span;
1801
1802   LttTime end;
1803   gtk_list_store_clear(event_viewer_data->store_m);
1804   g_ptr_array_set_size(event_viewer_data->pos, 0);
1805
1806   end = ltt_time_sub(time_span.end_time, time_span.start_time);
1807   event_viewer_data->vadjust_c->upper = ltt_time_to_double(end);
1808
1809   /* Reset the positions */
1810   lttv_traceset_context_position_destroy(
1811       event_viewer_data->currently_selected_position);
1812   lttv_traceset_context_position_destroy(
1813       event_viewer_data->first_event);
1814   lttv_traceset_context_position_destroy(
1815       event_viewer_data->last_event);
1816
1817   event_viewer_data->currently_selected_position =
1818     lttv_traceset_context_position_new(tsc);
1819   event_viewer_data->first_event =
1820     lttv_traceset_context_position_new(tsc);
1821   event_viewer_data->last_event =
1822     lttv_traceset_context_position_new(tsc);
1823
1824   get_events(event_viewer_data->vadjust_c->value, event_viewer_data);
1825   //  event_viewer_data->vadjust_c->value = 0;
1826
1827         request_background_data(event_viewer_data);
1828
1829   return FALSE;
1830 }
1831
1832 gboolean filter_changed(void * hook_data, void * call_data)
1833 {
1834   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1835   LttvTracesetContext * tsc =
1836         lttvwindow_get_traceset_context(event_viewer_data->tab);
1837
1838   event_viewer_data->main_win_filter =
1839     (LttvFilter*)call_data;
1840   get_events(event_viewer_data->vadjust_c->value, event_viewer_data);
1841
1842   return FALSE;
1843 }
1844
1845
1846 gint evd_redraw_notify(void *hook_data, void *call_data)
1847 {
1848   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1849
1850   get_events(event_viewer_data->vadjust_c->value, event_viewer_data);
1851   return 0;
1852 }
1853
1854 void gui_events_free(gpointer data)
1855 {
1856   LttvPluginEVD *plugin_evd = (LttvPluginEVD*)data;
1857   Tab *tab = plugin_evd->evd->tab;
1858   EventViewerData *event_viewer_data = plugin_evd->evd;
1859   guint i;
1860
1861   lttv_filter_destroy(plugin_evd->evd->filter);
1862
1863   if(tab != NULL){
1864     lttv_hooks_remove(event_viewer_data->event_hooks,event_hook);
1865     lttv_hooks_destroy(event_viewer_data->event_hooks);
1866
1867     for(i=0;i<event_viewer_data->pos->len;i++) {
1868       LttvTracesetContextPosition *cur_pos =
1869         (LttvTracesetContextPosition*)g_ptr_array_index(event_viewer_data->pos,
1870                                                         i);
1871       lttv_traceset_context_position_destroy(cur_pos);
1872     }
1873     lttv_traceset_context_position_destroy(
1874         event_viewer_data->currently_selected_position);
1875     lttv_traceset_context_position_destroy(
1876         event_viewer_data->first_event);
1877     lttv_traceset_context_position_destroy(
1878         event_viewer_data->last_event);
1879     g_ptr_array_free(event_viewer_data->pos, TRUE);
1880
1881     lttvwindow_unregister_current_time_notify(tab,
1882                         update_current_time, event_viewer_data);
1883     lttvwindow_unregister_current_position_notify(tab,
1884                         update_current_position, event_viewer_data);
1885     //lttvwindow_unregister_show_notify(tab,
1886     //                    show_event_detail, event_viewer_data);
1887     lttvwindow_unregister_traceset_notify(tab,
1888                         traceset_changed, event_viewer_data);
1889     lttvwindow_unregister_filter_notify(tab,
1890                         filter_changed, event_viewer_data);
1891     lttvwindow_unregister_redraw_notify(tab,
1892                 evd_redraw_notify, event_viewer_data);
1893
1894   }
1895   lttvwindowtraces_background_notify_remove(event_viewer_data);
1896
1897   g_event_viewer_data_list = g_slist_remove(g_event_viewer_data_list,
1898       event_viewer_data);
1899   //g_free(event_viewer_data);
1900   g_object_unref(plugin_evd);
1901 }
1902
1903
1904
1905 void gui_events_destructor(gpointer data)
1906 {
1907   LttvPluginEVD *plugin_evd = (LttvPluginEVD*)data;
1908   /* May already been done by GTK window closing */
1909   if(GTK_IS_WIDGET(plugin_evd->parent.top_widget)){
1910     gtk_widget_destroy(plugin_evd->parent.top_widget);
1911   }
1912 }
1913
1914
1915
1916 /**
1917  * plugin's init function
1918  *
1919  * This function initializes the Event Viewer functionnality through the
1920  * gtkTraceSet API.
1921  */
1922 static void init() {
1923
1924   lttvwindow_register_constructor("guievents",
1925                                   "/",
1926                                   "Insert Event Viewer",
1927                                   hGuiEventsInsert_xpm,
1928                                   "Insert Event Viewer",
1929                                   h_gui_events);
1930 }
1931
1932 void event_destroy_walk(gpointer data, gpointer user_data)
1933 {
1934   gui_events_destructor((LttvPluginEVD*)data);
1935 }
1936
1937 /**
1938  * plugin's destroy function
1939  *
1940  * This function releases the memory reserved by the module and unregisters
1941  * everything that has been registered in the gtkTraceSet API.
1942  */
1943 static void destroy() {
1944
1945   g_slist_foreach(g_event_viewer_data_list, event_destroy_walk, NULL );
1946   g_slist_free(g_event_viewer_data_list);
1947
1948   lttvwindow_unregister_constructor(h_gui_events);
1949
1950 }
1951
1952
1953
1954
1955 LTTV_MODULE("guievents", "Detailed events view", \
1956     "Graphical module to display a detailed event list", \
1957             init, destroy, "lttvwindow", "print")