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