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