lttv/modules/gui/detailedevents/events.c

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