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