ltt/branches/poly/lttv/modules/gui/detailedevents/events.c

   1 /* This file is part of the Linux Trace Toolkit viewer
   2  * Copyright (C) 2003-2004 Mathieu Desnoyers and XangXiu Yang
   3  *               2005 Mathieu Desnoyers
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License Version 2 as
   7  * published by the Free Software Foundation;
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  17  * MA 02111-1307, USA.
  18  */
  19
  20
  21 //*! \defgroup GuiEvents libGuiEvents: The GUI Events display plugin */
  22 /*\@{*/
  23
  24 /*! \file GuiEvents.c
  25  * \brief Graphical plugin for showing events.
  26  *
  27  * This plugin lists all the events contained in the current time interval
  28  * in a list.
  29  *
  30  * This plugin adds a Events Viewer functionnality to Linux TraceToolkit
  31  * GUI when this plugin is loaded. The init and destroy functions add the
  32  * viewer's insertion menu item and toolbar icon by calling viewer.h's
  33  * API functions. Then, when a viewer's object is created, the constructor
  34  * creates ans register through API functions what is needed to interact
  35  * with the lttvwindow.
  36  *
  37  * Authors : Mathieu Desnoyers and XangXiu Yang, June to December 2003
  38  *           Inspired from original LTT, made by Karim Yaghmour
  39  *
  40  *           Mostly rewritten by Mathieu Desnoyers, August 2005.
  41  */
  42
  43 #ifdef HAVE_CONFIG_H
  44 #include <config.h>
  45 #endif
  46
  47 #include <math.h>
  48
  49 #include <glib.h>
  50 #include <gtk/gtk.h>
  51 #include <gdk/gdk.h>
  52 #include <string.h>
  53
  54 #include <ltt/ltt.h>
  55 #include <ltt/event.h>
  56 #include <ltt/type.h>
  57 #include <ltt/trace.h>
  58 #include <ltt/facility.h>
  59 #include <lttv/module.h>
  60 #include <lttv/hook.h>
  61 #include <lttv/tracecontext.h>
  62 #include <lttv/state.h>
  63 #include <lttv/filter.h>
  64 #include <lttv/print.h>
  65 #include <lttvwindow/lttvwindow.h>
  66
  67 #include "hGuiEventsInsert.xpm"
  68
  69 #define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format)
  70
  71 #ifndef g_debug
  72 #define g_debug(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format)
  73 #endif
  74
  75 #define abs(a) (((a)<0)?(-a):(a))
  76
  77
  78 /** Array containing instanced objects. Used when module is unloaded */
  79 static GSList *g_event_viewer_data_list = NULL ;
  80
  81 typedef enum _ScrollDirection{
  82   SCROLL_STEP_UP,
  83   SCROLL_STEP_DOWN,
  84   SCROLL_PAGE_UP,
  85   SCROLL_PAGE_DOWN,
  86   SCROLL_JUMP,
  87   SCROLL_NONE
  88 } ScrollDirection;
  89
  90 typedef struct _EventViewerData {
  91
  92   Tab * tab;
  93   LttvHooks  * event_hooks;
  94
  95   /* previous value is used to determine if it is a page up/down or
  96    * step up/down, in which case we move of a certain amount of events (one or
  97    * the number of events shown on the screen) instead of changing begin time.
  98    */
  99   double       previous_value;
 100
 101   //scroll window containing Tree View
 102   GtkWidget * scroll_win;
 103
 104   /* Model containing list data */
 105   GtkListStore *store_m;
 106
 107   GPtrArray *pos; /* Array of LttvTracesetContextPosition * */
 108
 109   GtkWidget *top_widget;
 110   GtkWidget *hbox_v;
 111   /* Widget to display the data in a columned list */
 112   GtkWidget *tree_v;
 113   GtkAdjustment *vtree_adjust_c ;
 114   GtkWidget *button; /* a button of the header, used to get the header_height */
 115   gint header_height;
 116
 117   /* Vertical scrollbar and its adjustment */
 118   GtkWidget *vscroll_vc;
 119   GtkAdjustment *vadjust_c;
 120
 121   /* Selection handler */
 122   GtkTreeSelection *select_c;
 123
 124   gint num_visible_events;
 125
 126   LttvTracesetContextPosition *currently_selected_position;
 127
 128   LttvTracesetContextPosition *first_event;  /* Time of the first event shown */
 129   LttvTracesetContextPosition *last_event;  /* Time of the first event shown */
 130
 131   LttvFilter *main_win_filter;
 132
 133 } EventViewerData ;
 134
 135 /** hook functions for update time interval, current time ... */
 136 gboolean update_current_time(void * hook_data, void * call_data);
 137 gboolean update_current_position(void * hook_data, void * call_data);
 138 //gboolean show_event_detail(void * hook_data, void * call_data);
 139 gboolean traceset_changed(void * hook_data, void * call_data);
 140 gboolean filter_changed(void * hook_data, void * call_data);
 141
 142 //! Event Viewer's constructor hook
 143 GtkWidget *h_gui_events(Tab *tab);
 144 //! Event Viewer's constructor
 145 EventViewerData *gui_events(Tab *tab);
 146 //! Event Viewer's destructor
 147 void gui_events_destructor(EventViewerData *event_viewer_data);
 148 void gui_events_free(EventViewerData *event_viewer_data);
 149
 150 static gboolean
 151 header_size_allocate(GtkWidget *widget,
 152                         GtkAllocation *allocation,
 153                         gpointer user_data);
 154
 155 void tree_v_set_cursor(EventViewerData *event_viewer_data);
 156 void tree_v_get_cursor(EventViewerData *event_viewer_data);
 157
 158 /* Prototype for selection handler callback */
 159 static void tree_selection_changed_cb (GtkTreeSelection *selection,
 160     gpointer data);
 161 static void v_scroll_cb (GtkAdjustment *adjustment, gpointer data);
 162 static void tree_v_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc,
 163     gpointer data);
 164 static void tree_v_size_request_cb (GtkWidget *widget,
 165     GtkRequisition *requisition, gpointer data);
 166 static void tree_v_cursor_changed_cb (GtkWidget *widget, gpointer data);
 167 static void tree_v_move_cursor_cb (GtkWidget *widget, GtkMovementStep arg1,
 168     gint arg2, gpointer data);
 169
 170
 171 static void get_events(double time, EventViewerData *event_viewer_data);
 172
 173 int event_hook(void *hook_data, void *call_data);
 174
 175 /* Enumeration of the columns */
 176 enum
 177 {
 178   TRACE_NAME_COLUMN,
 179   TRACEFILE_NAME_COLUMN,
 180   CPUID_COLUMN,
 181   EVENT_COLUMN,
 182   FACILITY_COLUMN,
 183   TIME_S_COLUMN,
 184   TIME_NS_COLUMN,
 185   PID_COLUMN,
 186   EVENT_DESCR_COLUMN,
 187   POSITION_COLUMN,
 188   N_COLUMNS
 189 };
 190
 191 /**
 192  * Event Viewer's constructor hook
 193  *
 194  * This constructor is given as a parameter to the menuitem and toolbar button
 195  * registration. It creates the list.
 196  * @param parent_window A pointer to the parent window.
 197  * @return The widget created.
 198  */
 199 GtkWidget *
 200 h_gui_events(Tab * tab)
 201 {
 202   EventViewerData* event_viewer_data = gui_events(tab) ;
 203   if(event_viewer_data)
 204     return event_viewer_data->top_widget;
 205   else return NULL;
 206
 207 }
 208
 209 /**
 210  * Event Viewer's constructor
 211  *
 212  * This constructor is used to create EventViewerData data structure.
 213  * @return The Event viewer data created.
 214  */
 215 EventViewerData *
 216 gui_events(Tab *tab)
 217 {
 218   LttTime end;
 219   GtkTreeViewColumn *column;
 220   GtkCellRenderer *renderer;
 221   EventViewerData* event_viewer_data = g_new(EventViewerData,1) ;
 222
 223   event_viewer_data->tab = tab;
 224
 225   LttvTracesetContext * tsc =
 226         lttvwindow_get_traceset_context(event_viewer_data->tab);
 227
 228
 229   event_viewer_data->event_hooks = lttv_hooks_new();
 230   lttv_hooks_add(event_viewer_data->event_hooks,
 231                  event_hook,
 232                  event_viewer_data,
 233                  LTTV_PRIO_DEFAULT);
 234
 235   lttvwindow_register_current_time_notify(tab,
 236                 update_current_time,event_viewer_data);
 237   lttvwindow_register_current_position_notify(tab,
 238                 update_current_position,event_viewer_data);
 239   lttvwindow_register_traceset_notify(tab,
 240                 traceset_changed,event_viewer_data);
 241   lttvwindow_register_filter_notify(tab,
 242                 filter_changed, event_viewer_data);
 243
 244   event_viewer_data->scroll_win = gtk_scrolled_window_new (NULL, NULL);
 245   gtk_widget_show (event_viewer_data->scroll_win);
 246   gtk_scrolled_window_set_policy(
 247       GTK_SCROLLED_WINDOW(event_viewer_data->scroll_win),
 248       GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
 249
 250   event_viewer_data->currently_selected_position =
 251     lttv_traceset_context_position_new(tsc);
 252   event_viewer_data->first_event =
 253     lttv_traceset_context_position_new(tsc);
 254   event_viewer_data->last_event =
 255     lttv_traceset_context_position_new(tsc);
 256
 257   event_viewer_data->main_win_filter = NULL;
 258
 259   /* Create a model for storing the data list */
 260   event_viewer_data->store_m = gtk_list_store_new (
 261     N_COLUMNS,      /* Total number of columns     */
 262     G_TYPE_STRING,  /* Trace name                  */
 263     G_TYPE_STRING,  /* Tracefile name              */
 264     G_TYPE_UINT,    /* CPUID                       */
 265     G_TYPE_STRING,  /* Event                       */
 266     G_TYPE_STRING,  /* Facility                    */
 267     G_TYPE_UINT,    /* Time s                      */
 268     G_TYPE_UINT,    /* Time ns                     */
 269     G_TYPE_INT,     /* PID                         */
 270     G_TYPE_STRING,  /* Event's description         */
 271     G_TYPE_POINTER);/* Position (not shown)        */
 272
 273   event_viewer_data->pos = g_ptr_array_sized_new(10);
 274
 275   /* Create the viewer widget for the columned list */
 276   event_viewer_data->tree_v =
 277     gtk_tree_view_new_with_model (GTK_TREE_MODEL (event_viewer_data->store_m));
 278
 279   g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "size-allocate",
 280         G_CALLBACK (tree_v_size_allocate_cb),
 281         event_viewer_data);
 282   g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "size-request",
 283         G_CALLBACK (tree_v_size_request_cb),
 284         event_viewer_data);
 285
 286   g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "cursor-changed",
 287         G_CALLBACK (tree_v_cursor_changed_cb),
 288         event_viewer_data);
 289
 290   g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "move-cursor",
 291         G_CALLBACK (tree_v_move_cursor_cb),
 292         event_viewer_data);
 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 ("Facility",
 358                  renderer,
 359                  "text", FACILITY_COLUMN,
 360                  NULL);
 361   gtk_tree_view_column_set_alignment (column, 0.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 (s)",
 368                  renderer,
 369                  "text", TIME_S_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   renderer = gtk_cell_renderer_text_new ();
 377   column = gtk_tree_view_column_new_with_attributes ("Time (ns)",
 378                  renderer,
 379                  "text", TIME_NS_COLUMN,
 380                  NULL);
 381   gtk_tree_view_column_set_alignment (column, 1.0);
 382   gtk_tree_view_column_set_fixed_width (column, 120);
 383   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 384       column);
 385
 386
 387   renderer = gtk_cell_renderer_text_new ();
 388   column = gtk_tree_view_column_new_with_attributes ("PID",
 389                  renderer,
 390                  "text", PID_COLUMN,
 391                  NULL);
 392   gtk_tree_view_column_set_alignment (column, 1.0);
 393   gtk_tree_view_column_set_fixed_width (column, 45);
 394   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 395       column);
 396
 397   renderer = gtk_cell_renderer_text_new ();
 398   column = gtk_tree_view_column_new_with_attributes ("Event Description",
 399                  renderer,
 400                  "text", EVENT_DESCR_COLUMN,
 401                  NULL);
 402   gtk_tree_view_column_set_alignment (column, 0.0);
 403   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 404       column);
 405
 406
 407   /* Setup the selection handler */
 408   event_viewer_data->select_c =
 409     gtk_tree_view_get_selection (GTK_TREE_VIEW (event_viewer_data->tree_v));
 410   gtk_tree_selection_set_mode (event_viewer_data->select_c,
 411       GTK_SELECTION_SINGLE);
 412   g_signal_connect (G_OBJECT (event_viewer_data->select_c), "changed",
 413         G_CALLBACK (tree_selection_changed_cb),
 414         event_viewer_data);
 415
 416   gtk_container_add (GTK_CONTAINER (event_viewer_data->scroll_win),
 417       event_viewer_data->tree_v);
 418
 419   event_viewer_data->hbox_v = gtk_hbox_new(0, 0);
 420   event_viewer_data->top_widget = event_viewer_data->hbox_v;
 421   gtk_box_pack_start(GTK_BOX(event_viewer_data->hbox_v),
 422       event_viewer_data->scroll_win, TRUE, TRUE, 0);
 423
 424   /* Create vertical scrollbar and pack it */
 425   event_viewer_data->vscroll_vc = gtk_vscrollbar_new(NULL);
 426   gtk_range_set_update_policy (GTK_RANGE(event_viewer_data->vscroll_vc),
 427              GTK_UPDATE_CONTINUOUS);
 428              // Changed by MD : more user friendly :)
 429              //GTK_UPDATE_DISCONTINUOUS);
 430   gtk_box_pack_start(GTK_BOX(event_viewer_data->hbox_v),
 431       event_viewer_data->vscroll_vc, FALSE, TRUE, 0);
 432
 433   /* Get the vertical scrollbar's adjustment */
 434   event_viewer_data->vadjust_c =
 435     gtk_range_get_adjustment(GTK_RANGE(event_viewer_data->vscroll_vc));
 436   event_viewer_data->vtree_adjust_c = gtk_tree_view_get_vadjustment(
 437                     GTK_TREE_VIEW (event_viewer_data->tree_v));
 438
 439   g_signal_connect (G_OBJECT (event_viewer_data->vadjust_c), "value-changed",
 440         G_CALLBACK (v_scroll_cb),
 441         event_viewer_data);
 442   /* Set the upper bound to the last event number */
 443   event_viewer_data->previous_value = 0;
 444   event_viewer_data->vadjust_c->lower = 0.0;
 445     //event_viewer_data->vadjust_c->upper = event_viewer_data->number_of_events;
 446   event_viewer_data->vadjust_c->value = 0.0;
 447   event_viewer_data->vadjust_c->step_increment = 1.0;
 448   event_viewer_data->vadjust_c->page_increment = 2.0;
 449     //  event_viewer_data->vtree_adjust_c->upper;
 450   event_viewer_data->vadjust_c->page_size = 2.0;
 451   //    event_viewer_data->vtree_adjust_c->upper;
 452   /*  Raw event trace */
 453   gtk_widget_show(event_viewer_data->hbox_v);
 454   gtk_widget_show(event_viewer_data->tree_v);
 455   gtk_widget_show(event_viewer_data->vscroll_vc);
 456
 457   /* Add the object's information to the module's array */
 458   g_event_viewer_data_list = g_slist_append(g_event_viewer_data_list,
 459       event_viewer_data);
 460
 461   event_viewer_data->num_visible_events = 1;
 462
 463   //get the life span of the traceset and set the upper of the scroll bar
 464
 465   TimeInterval time_span = tsc->time_span;
 466   end = ltt_time_sub(time_span.end_time, time_span.start_time);
 467
 468   event_viewer_data->vadjust_c->upper =
 469               ltt_time_to_double(end);
 470
 471   /* Set the Selected Event */
 472   //  tree_v_set_cursor(event_viewer_data);
 473
 474  // event_viewer_data->current_time_updated = FALSE;
 475  //
 476   g_object_set_data_full(
 477       G_OBJECT(event_viewer_data->hbox_v),
 478       "event_viewer_data",
 479       event_viewer_data,
 480       (GDestroyNotify)gui_events_free);
 481
 482
 483   return event_viewer_data;
 484 }
 485
 486
 487
 488 static gboolean
 489 header_size_allocate(GtkWidget *widget,
 490                         GtkAllocation *allocation,
 491                         gpointer user_data)
 492 {
 493   EventViewerData *event_viewer_data = (EventViewerData*)user_data;
 494
 495   event_viewer_data->header_height = allocation->height;
 496
 497   return 0;
 498 }
 499
 500
 501 void tree_v_set_cursor(EventViewerData *event_viewer_data)
 502 {
 503   GtkTreePath *path;
 504
 505   g_debug("set cursor cb");
 506
 507 #if 0
 508   if(event_viewer_data->currently_selected_event != -1)
 509     {
 510       path = gtk_tree_path_new_from_indices(
 511               event_viewer_data->currently_selected_event,
 512               -1);
 513
 514       gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 515           path, NULL, FALSE);
 516       gtk_tree_path_free(path);
 517     }
 518 #endif //0
 519 }
 520
 521 void tree_v_get_cursor(EventViewerData *event_viewer_data)
 522 {
 523   GtkTreePath *path;
 524   gint *indices;
 525
 526   g_debug("get cursor cb");
 527
 528
 529 #if 0
 530   gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 531       &path, NULL);
 532   indices = gtk_tree_path_get_indices(path);
 533
 534   if(indices != NULL)
 535       event_viewer_data->currently_selected_event = indices[0];
 536     else
 537       event_viewer_data->currently_selected_event = -1;
 538
 539   gtk_tree_path_free(path);
 540 #endif //0
 541 }
 542
 543
 544
 545 void tree_v_move_cursor_cb (GtkWidget *widget,
 546                             GtkMovementStep arg1,
 547                             gint arg2,
 548                             gpointer data)
 549 {
 550   GtkTreePath *path; // = gtk_tree_path_new();
 551   gint *indices;
 552   gdouble value;
 553   EventViewerData *event_viewer_data = (EventViewerData*)data;
 554
 555   g_debug("move cursor cb");
 556   //gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 557   //                          &path, NULL);
 558   //if(path == NULL)
 559   //{
 560     /* No prior cursor, put it at beginning of page
 561      * and let the execution do */
 562   //  path = gtk_tree_path_new_from_indices(0, -1);
 563   //  gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 564   //                              path, NULL, FALSE);
 565   //}
 566
 567   //indices = gtk_tree_path_get_indices(path);
 568
 569   //value = gtk_adjustment_get_value(event_viewer_data->vadjust_c);
 570
 571   /* If no prior position... */
 572   if(ltt_time_compare(
 573         lttv_traceset_context_position_get_time(
 574           event_viewer_data->currently_selected_position),
 575         ltt_time_infinite) == 0) {
 576
 577     path = gtk_tree_path_new_from_indices(0, -1);
 578     gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 579                                 path, NULL, FALSE);
 580
 581     gtk_tree_path_free(path);
 582     return;
 583
 584   }
 585
 586
 587   g_debug("tree view move cursor : arg1 is %u and arg2 is %d",
 588       (guint)arg1, arg2);
 589
 590   switch(arg1) {
 591   case GTK_MOVEMENT_DISPLAY_LINES:
 592     if(arg2 == 1) {
 593       /* Move one line down */
 594       if(event_viewer_data->pos->len > 0) {
 595         LttvTracesetContextPosition *end_pos =
 596           (LttvTracesetContextPosition*)g_ptr_array_index(
 597                                              event_viewer_data->pos,
 598                                              event_viewer_data->pos->len - 1);
 599         if(lttv_traceset_context_pos_pos_compare(end_pos,
 600               event_viewer_data->currently_selected_position) == 0) {
 601           /* Must get down one event and select the last one */
 602           gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
 603                 GTK_TREE_VIEW(event_viewer_data->tree_v)));
 604           gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 605               gtk_adjustment_get_value(event_viewer_data->vadjust_c) + 1);
 606           path = gtk_tree_path_new_from_indices(
 607               event_viewer_data->pos->len - 1, -1);
 608           gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 609                                    path, NULL, FALSE);
 610           gtk_tree_path_free(path);
 611         }
 612 #if 0
 613           GtkTreePath *path = gtk_tree_path_new_from_indices(i, -1);
 614           gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 615                                  path, NULL, FALSE);
 616           gtk_tree_path_free(path);
 617 #endif //0
 618       }
 619
 620     } else {
 621       if(event_viewer_data->pos->len > 0) {
 622         /* Move one line up */
 623         LttvTracesetContextPosition *begin_pos =
 624           (LttvTracesetContextPosition*)g_ptr_array_index(
 625                                              event_viewer_data->pos,
 626                                              0);
 627         if(lttv_traceset_context_pos_pos_compare(begin_pos,
 628               event_viewer_data->currently_selected_position) == 0) {
 629           /* Must get up one event and select the first one */
 630           gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
 631                 GTK_TREE_VIEW(event_viewer_data->tree_v)));
 632           gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 633               gtk_adjustment_get_value(event_viewer_data->vadjust_c) - 1);
 634           path = gtk_tree_path_new_from_indices(
 635               0, -1);
 636           gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 637                                    path, NULL, FALSE);
 638           gtk_tree_path_free(path);
 639         }
 640       }
 641     }
 642     break;
 643   case GTK_MOVEMENT_PAGES:
 644     if(arg2 == 1) {
 645       /* Move one page down */
 646       if(event_viewer_data->pos->len > 0) {
 647         LttvTracesetContextPosition *end_pos =
 648           (LttvTracesetContextPosition*)g_ptr_array_index(
 649                                              event_viewer_data->pos,
 650                                              event_viewer_data->pos->len - 1);
 651         if(lttv_traceset_context_pos_pos_compare(end_pos,
 652               event_viewer_data->currently_selected_position) == 0) {
 653           /* Must get down one page and select the last one */
 654           gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
 655                 GTK_TREE_VIEW(event_viewer_data->tree_v)));
 656
 657           gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 658               gtk_adjustment_get_value(event_viewer_data->vadjust_c) + 2);
 659
 660           path = gtk_tree_path_new_from_indices(
 661               event_viewer_data->pos->len - 1, -1);
 662           gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 663                                    path, NULL, FALSE);
 664           gtk_tree_path_free(path);
 665
 666         }
 667       }
 668
 669     } else {
 670       /* Move one page up */
 671       if(event_viewer_data->pos->len > 0) {
 672         LttvTracesetContextPosition *begin_pos =
 673           (LttvTracesetContextPosition*)g_ptr_array_index(
 674                                              event_viewer_data->pos,
 675                                              0);
 676         if(lttv_traceset_context_pos_pos_compare(begin_pos,
 677               event_viewer_data->currently_selected_position) == 0) {
 678           /* Must get up one page and select the first one */
 679           gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
 680                 GTK_TREE_VIEW(event_viewer_data->tree_v)));
 681
 682           gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 683               gtk_adjustment_get_value(event_viewer_data->vadjust_c) - 2);
 684
 685           path = gtk_tree_path_new_from_indices(
 686               0, -1);
 687           gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 688                                    path, NULL, FALSE);
 689           gtk_tree_path_free(path);
 690         }
 691       }
 692
 693     }
 694     break;
 695   default:
 696     break;
 697   }
 698
 699   //gtk_tree_path_free(path);
 700
 701 #if 0
 702   if(arg1 == GTK_MOVEMENT_DISPLAY_LINES)
 703   {
 704     /* Move one line */
 705     if(arg2 == 1)
 706     {
 707       /* move one line down */
 708       if(indices[0]) // Do we need an empty field here (before first)?
 709       {
 710         if(value + event_viewer_data->num_visible_events <=
 711             event_viewer_data->number_of_events -1)
 712         {
 713           event_viewer_data->currently_selected_event += 1;
 714           //      gtk_adjustment_set_value(event_viewer_data->vadjust_c, value+1);
 715           //gtk_tree_path_free(path);
 716           //path = gtk_tree_path_new_from_indices(event_viewer_data->num_visible_events-1, -1);
 717           //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 718           g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 719         }
 720       }
 721     } else {
 722       /* Move one line up */
 723       if(indices[0] == 0)
 724       {
 725         if(value - 1 >= 0 )
 726         {
 727           event_viewer_data->currently_selected_event -= 1;
 728           //      gtk_adjustment_set_value(event_viewer_data->vadjust_c, value-1);
 729           //gtk_tree_path_free(path);
 730           //path = gtk_tree_path_new_from_indices(0, -1);
 731           //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 732           g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 733         }
 734       }
 735     }
 736   }
 737
 738   if(arg1 == GTK_MOVEMENT_PAGES)
 739   {
 740     /* Move one page */
 741     if(arg2 == 1)
 742     {
 743       if(event_viewer_data->num_visible_events == 1)
 744         value += 1 ;
 745       /* move one page down */
 746       if(value + event_viewer_data->num_visible_events-1 <=
 747                       event_viewer_data->number_of_events )
 748       {
 749         event_viewer_data->currently_selected_event +=
 750                                   event_viewer_data->num_visible_events-1;
 751         //        gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 752         //               value+(event_viewer_data->num_visible_events-1));
 753         //gtk_tree_path_free(path);
 754         //path = gtk_tree_path_new_from_indices(0, -1);
 755         //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 756         g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 757       }
 758     } else {
 759       /* Move one page up */
 760       if(event_viewer_data->num_visible_events == 1)
 761         value -= 1 ;
 762
 763       if(indices[0] < event_viewer_data->num_visible_events - 2 )
 764       {
 765         if(value - (event_viewer_data->num_visible_events-1) >= 0)
 766         {
 767           event_viewer_data->currently_selected_event -=
 768                           event_viewer_data->num_visible_events-1;
 769
 770           //      gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 771           //             value-(event_viewer_data->num_visible_events-1));
 772           //gtk_tree_path_free(path);
 773           //path = gtk_tree_path_new_from_indices(0, -1);
 774           //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 775           g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 776
 777         } else {
 778           /* Go to first Event */
 779           event_viewer_data->currently_selected_event == 0 ;
 780           //      gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 781           //             0);
 782           //gtk_tree_path_free(path);
 783           //path = gtk_tree_path_new_from_indices(0, -1);
 784           //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 785           g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 786
 787         }
 788       }
 789     }
 790   }
 791
 792   if(arg1 == GTK_MOVEMENT_BUFFER_ENDS)
 793   {
 794     /* Move to the ends of the buffer */
 795     if(arg2 == 1)
 796     {
 797       /* move end of buffer */
 798       event_viewer_data->currently_selected_event =
 799                             event_viewer_data->number_of_events-1 ;
 800       //    gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 801       //           event_viewer_data->number_of_events -
 802       //           event_viewer_data->num_visible_events);
 803       //gtk_tree_path_free(path);
 804       //path = gtk_tree_path_new_from_indices(event_viewer_data->num_visible_events-1, -1);
 805       //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 806       g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 807     } else {
 808       /* Move beginning of buffer */
 809       event_viewer_data->currently_selected_event = 0 ;
 810       //    gtk_adjustment_set_value(event_viewer_data->vadjust_c, 0);
 811         //gtk_tree_path_free(path);
 812         //path = gtk_tree_path_new_from_indices(0, -1);
 813         //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 814       g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 815     }
 816   }
 817 #endif //0
 818 }
 819
 820 void tree_v_cursor_changed_cb (GtkWidget *widget, gpointer data)
 821 {
 822   EventViewerData *event_viewer_data = (EventViewerData*) data;
 823   Tab *tab = event_viewer_data->tab;
 824   GtkTreeIter iter;
 825   GtkTreeModel* model = GTK_TREE_MODEL(event_viewer_data->store_m);
 826   GtkTreePath *path;
 827   LttvTracesetContextPosition *pos;
 828
 829   g_debug("cursor changed cb");
 830
 831   /* On cursor change, modify the currently selected event by calling
 832    * the right API function */
 833   tree_v_get_cursor(event_viewer_data);
 834
 835   gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 836       &path, NULL);
 837   if(gtk_tree_model_get_iter(model,&iter,path)){
 838     gtk_tree_model_get(model, &iter, POSITION_COLUMN, &pos, -1);
 839
 840     lttvwindow_report_current_position(tab, pos);
 841   }else{
 842     g_warning("Can not get iter\n");
 843   }
 844 }
 845
 846
 847 static void tree_selection_changed_cb (GtkTreeSelection *selection,
 848     gpointer data)
 849 {
 850   g_debug("tree sel changed cb");
 851   EventViewerData *event_viewer_data = (EventViewerData*) data;
 852 #if 0
 853     /* Set the cursor to currently selected event */
 854   GtkTreeModel* model = GTK_TREE_MODEL(event_viewer_data->store_m);
 855   GtkTreeIter iter;
 856   LttvTracesetContextPosition *pos;
 857   guint i;
 858   GtkTreePath *tree_path;
 859
 860   for(i=0;i<event_viewer_data->num_visible_events;i++) {
 861     tree_path = gtk_tree_path_new_from_indices(
 862                 i,
 863                -1);
 864     if(gtk_tree_model_get_iter(model,&iter,tree_path)){
 865       gtk_tree_model_get(model, &iter, POSITION_COLUMN, &pos, -1);
 866
 867       if(lttv_traceset_context_pos_pos_compare(pos,
 868             event_viewer_data->currently_selected_position) == 0) {
 869         /* Match! */
 870             gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 871                 tree_path, NULL, FALSE);
 872         break;
 873       }
 874
 875     }else{
 876       g_warning("Can not get iter\n");
 877     }
 878    gtk_tree_path_free(tree_path);
 879   }
 880 #endif //0
 881 }
 882
 883
 884
 885 /* This callback may be recalled after a step up/down, but we don't want to lose
 886  * the exact position : what we do is that we only set the value if it has
 887  * changed : a step up/down that doesn't change the time value of the first
 888  * event won't trigger a scrollbar change. */
 889
 890 void v_scroll_cb (GtkAdjustment *adjustment, gpointer data)
 891 {
 892   EventViewerData *event_viewer_data = (EventViewerData*)data;
 893   LttvTracesetStats *tss =
 894     lttvwindow_get_traceset_stats(event_viewer_data->tab);
 895   LttvTracesetContext *tsc = (LttvTracesetContext*)tss;
 896   g_debug("SCROLL begin");
 897   g_debug("SCROLL values : %g , %g, %g",
 898       adjustment->value, event_viewer_data->previous_value,
 899       (adjustment->value - event_viewer_data->previous_value));
 900
 901   LttTime new_time_off = ltt_time_from_double(adjustment->value);
 902   LttTime old_time_off = ltt_time_from_double(event_viewer_data->previous_value);
 903   g_debug("SCROLL time values %lu.%lu, %lu.%lu", new_time_off.tv_sec,
 904       new_time_off.tv_nsec, old_time_off.tv_sec, old_time_off.tv_nsec);
 905   /* If same value : nothing to update */
 906   if(ltt_time_compare(new_time_off, old_time_off) == 0)
 907     return;
 908
 909   //LttTime old_time = event_viewer_data->first_event;
 910
 911   get_events(adjustment->value, event_viewer_data);
 912 #if 0
 913   LttTime time = ltt_time_sub(event_viewer_data->first_event,
 914                               tsc->time_span.start_time);
 915   double value = ltt_time_to_double(time);
 916   gtk_adjustment_set_value(event_viewer_data->vadjust_c, value);
 917
 918   if(event_viewer_data->currently_selected_event != -1) {
 919
 920       tree_path = gtk_tree_path_new_from_indices(
 921              event_viewer_data->currently_selected_event,
 922              -1);
 923
 924       //      gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), tree_path,
 925       //             NULL, FALSE);
 926       gtk_tree_path_free(tree_path);
 927   }
 928 #endif //0
 929   g_debug("SCROLL end");
 930 }
 931
 932 static __inline gint get_cell_height(GtkTreeView *TreeView)
 933 {
 934   gint height;
 935   GtkTreeViewColumn *column = gtk_tree_view_get_column(TreeView, 0);
 936
 937   gtk_tree_view_column_cell_get_size(column, NULL, NULL, NULL, NULL, &height);
 938
 939   return height;
 940 }
 941
 942 void tree_v_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data)
 943 {
 944   EventViewerData *event_viewer_data = (EventViewerData*)data;
 945   gint cell_height = get_cell_height(GTK_TREE_VIEW(event_viewer_data->tree_v));
 946   gint last_num_visible_events = event_viewer_data->num_visible_events;
 947   gdouble exact_num_visible;
 948
 949   exact_num_visible = ( alloc->height -
 950           event_viewer_data->header_height )
 951             / (double)cell_height ;
 952
 953   event_viewer_data->num_visible_events = ceil(exact_num_visible) ;
 954
 955 /*
 956   event_viewer_data->vadjust_c->page_increment =
 957     floor(exact_num_visible);
 958   event_viewer_data->vadjust_c->page_size =
 959     floor(exact_num_visible);
 960 */
 961
 962   g_debug("size allocate : last_num_visible_events : %d,\
 963            num_visible_events : %d",
 964            last_num_visible_events,
 965            event_viewer_data->num_visible_events);
 966   if(event_viewer_data->num_visible_events != last_num_visible_events)
 967     {
 968       get_events(event_viewer_data->vadjust_c->value, event_viewer_data);
 969     }
 970
 971
 972 }
 973
 974 void tree_v_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data)
 975 {
 976   gint h;
 977   EventViewerData *event_viewer_data = (EventViewerData*)data;
 978   gint cell_height = get_cell_height(GTK_TREE_VIEW(event_viewer_data->tree_v));
 979
 980   h = cell_height + event_viewer_data->header_height;
 981   requisition->height = h;
 982
 983 }
 984
 985 #if 0
 986 gboolean show_event_detail(void * hook_data, void * call_data)
 987 {
 988   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
 989   LttvTracesetContext * tsc = lttvwindow_get_traceset_context(event_viewer_data->tab);
 990
 991   if(event_viewer_data->event_fields_queue_tmp->length == 0 &&
 992      event_viewer_data->event_fields_queue->length == 0){
 993     event_viewer_data->shown = FALSE;
 994     return FALSE;
 995   }
 996
 997   if(event_viewer_data->shown == FALSE){
 998     event_viewer_data->shown = TRUE;
 999     update_raw_data_array(event_viewer_data,
1000         event_viewer_data->event_fields_queue_tmp->length);
1001
1002     get_data(event_viewer_data->vadjust_c->value,
1003       event_viewer_data->num_visible_events,
1004       event_viewer_data);
1005
1006     remove_context_hooks(event_viewer_data,tsc);
1007   }
1008
1009   return FALSE;
1010 }
1011 #endif //0
1012
1013
1014
1015
1016
1017
1018
1019 static void get_events(double new_value, EventViewerData *event_viewer_data)
1020 {
1021   GtkTreePath *tree_path;
1022   LttvTracesetStats *tss =
1023     lttvwindow_get_traceset_stats(event_viewer_data->tab);
1024   LttvTracesetContext *tsc = (LttvTracesetContext*)tss;
1025   guint i;
1026   gboolean seek_by_time;
1027
1028   double value = new_value - event_viewer_data->previous_value;
1029
1030   /* See where we have to scroll... */
1031   ScrollDirection direction;
1032   gint relative_position;
1033
1034   if(value < 0.0) {
1035     if(value >= -1.0) direction = SCROLL_STEP_UP;
1036     else {
1037       if(value >= -2.0) direction = SCROLL_PAGE_UP;
1038       else direction = SCROLL_JUMP;
1039     }
1040   } else if(value > 0.0) {
1041     if(value <= 1.0) direction = SCROLL_STEP_DOWN;
1042     else {
1043       if(value <= 2.0) direction = SCROLL_PAGE_DOWN;
1044       else direction = SCROLL_JUMP;
1045     }
1046   } else direction = SCROLL_NONE; /* 0.0 */
1047
1048
1049   switch(direction) {
1050   case SCROLL_STEP_UP:
1051     g_debug("get_events : SCROLL_STEP_UP");
1052     relative_position = -1;
1053     seek_by_time = 0;
1054     break;
1055   case SCROLL_STEP_DOWN:
1056     g_debug("get_events : SCROLL_STEP_DOWN");
1057     relative_position = 1;
1058     seek_by_time = 0;
1059     break;
1060   case SCROLL_PAGE_UP:
1061     g_debug("get_events : SCROLL_PAGE_UP");
1062     relative_position = -(event_viewer_data->num_visible_events);
1063     seek_by_time = 0;
1064     break;
1065   case SCROLL_PAGE_DOWN:
1066     g_debug("get_events : SCROLL_PAGE_DOWN");
1067     relative_position = event_viewer_data->num_visible_events;
1068     seek_by_time = 0;
1069     break;
1070   case SCROLL_JUMP:
1071     g_debug("get_events : SCROLL_JUMP");
1072     seek_by_time = 1;
1073     break;
1074   case SCROLL_NONE:
1075     g_debug("get_events : SCROLL_NONE");
1076     relative_position = 0;
1077     seek_by_time = 0;
1078     break;
1079   }
1080
1081   LttTime time = ltt_time_from_double(new_value);
1082   time = ltt_time_add(tsc->time_span.start_time, time);
1083
1084   if(!seek_by_time) {
1085
1086     LttvTracesetContextPosition *pos =
1087         lttv_traceset_context_position_new(tsc);
1088
1089   /* Remember the beginning position */
1090     if(event_viewer_data->pos->len > 0) {
1091       LttvTracesetContextPosition *first_pos =
1092         (LttvTracesetContextPosition*)g_ptr_array_index(event_viewer_data->pos,
1093                                                         0);
1094       lttv_traceset_context_position_copy(pos, first_pos);
1095       g_assert(lttv_process_traceset_seek_position(tsc, pos) == 0);
1096     } else {
1097       /* There is nothing in the list : simply seek to the time value. */
1098       lttv_state_traceset_seek_time_closest((LttvTracesetState*)tsc,
1099           time);
1100       lttv_process_traceset_middle(tsc, time, G_MAXUINT,
1101                                    NULL);
1102     }
1103
1104   /* Note that, as we mess with the tsc position, this function CANNOT be called
1105    * from a hook inside the lttv_process_traceset_middle. */
1106   /* As the lttvwindow API keeps a sync_position inside the tsc to go back at
1107    * the right spot after being interrupted, it's ok to change the tsc position,
1108    * as long as we do not touch the sync_position. */
1109
1110   /* Get the beginning position of the read (with seek backward or seek forward)
1111    */
1112     if(relative_position > 0) {
1113       guint count;
1114       count = lttv_process_traceset_seek_n_forward(tsc, relative_position,
1115           event_viewer_data->main_win_filter);
1116     } else if(relative_position < 0) {
1117       guint count;
1118
1119       /* Get an idea of currently shown event dispersion */
1120       LttTime first_event_time =
1121         lttv_traceset_context_position_get_time(event_viewer_data->first_event);
1122       LttTime last_event_time =
1123         lttv_traceset_context_position_get_time(event_viewer_data->last_event);
1124       LttTime time_diff = ltt_time_sub(last_event_time, first_event_time);
1125       if(ltt_time_compare(time_diff, ltt_time_zero) == 0)
1126         time_diff = seek_back_default_offset;
1127       count = lttv_process_traceset_seek_n_backward(tsc, abs(relative_position),
1128           time_diff,
1129           (seek_time_fct)lttv_state_traceset_seek_time_closest,
1130           event_viewer_data->main_win_filter);
1131     } /* else 0 : do nothing : we are already at the beginning position */
1132
1133     lttv_traceset_context_position_destroy(pos);
1134
1135     /* Save the first event position */
1136     lttv_traceset_context_position_save(tsc, event_viewer_data->first_event);
1137
1138     time = lttv_traceset_context_position_get_time(
1139                                             event_viewer_data->first_event);
1140     LttTime time_val = ltt_time_sub(time,
1141                         tsc->time_span.start_time);
1142     event_viewer_data->previous_value = ltt_time_to_double(time_val);
1143
1144     lttv_state_traceset_seek_time_closest((LttvTracesetState*)tsc, time);
1145     lttv_process_traceset_middle(tsc, ltt_time_infinite, G_MAXUINT,
1146                                  event_viewer_data->first_event);
1147
1148   } else {
1149     /* Seek by time */
1150     lttv_state_traceset_seek_time_closest((LttvTracesetState*)tsc,
1151           time);
1152     lttv_process_traceset_middle(tsc, time, G_MAXUINT,
1153                                  NULL);
1154     LttTime time_val = ltt_time_sub(time,
1155                         tsc->time_span.start_time);
1156     event_viewer_data->previous_value = ltt_time_to_double(time_val);
1157     lttv_traceset_context_position_save(tsc, event_viewer_data->first_event);
1158   }
1159
1160   /* Clear the model (don't forget to free the TCS positions!) */
1161   gtk_list_store_clear(event_viewer_data->store_m);
1162   for(i=0;i<event_viewer_data->pos->len;i++) {
1163     LttvTracesetContextPosition *cur_pos =
1164       (LttvTracesetContextPosition*)g_ptr_array_index(event_viewer_data->pos,
1165                                                       i);
1166     lttv_traceset_context_position_destroy(cur_pos);
1167   }
1168   g_ptr_array_set_size(event_viewer_data->pos, 0);
1169
1170
1171   /* Mathieu :
1172    * I make the choice not to use the mainwindow lttvwindow API here : it will
1173    * be faster to read the events ourself from lttv_process_traceset_middle, as
1174    * we are already at the right read position. It would be costier to use the
1175    * seek time closest for nothing, as we only have few events to read.
1176    */
1177   /* FIXME : use seek time closest and middle to have a good state. */
1178
1179   lttv_process_traceset_begin(tsc,
1180       NULL, NULL, NULL, event_viewer_data->event_hooks, NULL);
1181
1182   lttv_process_traceset_middle(tsc, ltt_time_infinite, G_MAXUINT, NULL);
1183
1184   lttv_process_traceset_end(tsc,
1185       NULL, NULL, NULL, event_viewer_data->event_hooks, NULL);
1186
1187   /* Get the end position */
1188   if(event_viewer_data->pos->len > 0) {
1189     LttvTracesetContextPosition *cur_pos =
1190       (LttvTracesetContextPosition*)g_ptr_array_index(event_viewer_data->pos,
1191                                                event_viewer_data->pos->len - 1);
1192     lttv_traceset_context_position_copy(event_viewer_data->last_event,
1193         cur_pos);
1194   } else
1195     lttv_traceset_context_position_save(tsc, event_viewer_data->last_event);
1196
1197   gtk_adjustment_set_value(event_viewer_data->vadjust_c,
1198       event_viewer_data->previous_value);
1199
1200   //g_signal_emit_by_name(G_OBJECT (event_viewer_data->select_c),
1201   //    "changed");
1202
1203
1204   return;
1205 }
1206
1207
1208
1209 int event_hook(void *hook_data, void *call_data)
1210 {
1211   EventViewerData *event_viewer_data = (EventViewerData*)hook_data;
1212   LttvTracefileContext *tfc = (LttvTracefileContext*)call_data;
1213   LttEvent *e = ltt_tracefile_get_event(tfc->tf);
1214
1215   LttvFilter *filter = event_viewer_data->main_win_filter;
1216   if(filter != NULL && filter->head != NULL)
1217     if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1218           tfc->t_context->t,tfc))
1219       return FALSE;
1220
1221   LttFacility *facility = ltt_event_facility(e);
1222   LttEventType *event_type = ltt_event_eventtype(e);
1223   LttField *field = ltt_event_field(e);
1224   LttTime time = ltt_event_time(e);
1225
1226   guint cpu = ltt_tracefile_num(tfc->tf);
1227   LttvTraceState *ts = (LttvTraceState*)tfc->t_context;
1228   LttvProcessState *process = ts->running_process[cpu];
1229
1230   GtkTreeIter iter;
1231
1232   GString *desc = g_string_new("");
1233
1234   LttvTracesetContextPosition *pos =
1235     lttv_traceset_context_position_new(tfc->t_context->ts_context);
1236
1237   lttv_traceset_context_position_save(tfc->t_context->ts_context, pos);
1238
1239   if(field)
1240     lttv_print_field(e, field, desc, TRUE);
1241
1242   g_info("field : %s", desc->str);
1243
1244   gtk_list_store_append (event_viewer_data->store_m, &iter);
1245   gtk_list_store_set (event_viewer_data->store_m, &iter,
1246       TRACE_NAME_COLUMN, g_quark_to_string(ltt_trace_name(tfc->t_context->t)),
1247       TRACEFILE_NAME_COLUMN, g_quark_to_string(ltt_tracefile_name(tfc->tf)),
1248       CPUID_COLUMN, cpu,
1249       FACILITY_COLUMN, g_quark_to_string(ltt_facility_name(facility)),
1250       EVENT_COLUMN, g_quark_to_string(ltt_eventtype_name(event_type)),
1251       TIME_S_COLUMN, time.tv_sec,
1252       TIME_NS_COLUMN, time.tv_nsec,
1253       PID_COLUMN, process->pid,
1254       EVENT_DESCR_COLUMN, desc->str,
1255       POSITION_COLUMN, pos,
1256       -1);
1257
1258   g_ptr_array_add(event_viewer_data->pos, pos);
1259
1260   g_string_free(desc, TRUE);
1261
1262   if(lttv_traceset_context_pos_pos_compare(pos,
1263         event_viewer_data->currently_selected_position) == 0) {
1264     GtkTreePath *path = gtk_tree_path_new_from_indices(
1265                         event_viewer_data->pos->len - 1, -1);
1266     gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
1267                            path, NULL, FALSE);
1268     gtk_tree_path_free(path);
1269   }
1270
1271   if(event_viewer_data->pos->len >= event_viewer_data->num_visible_events -1 )
1272     return TRUE;
1273   else
1274     return FALSE;
1275 }
1276
1277
1278
1279 static void event_update_selection(EventViewerData *event_viewer_data)
1280 {
1281   guint i;
1282   GPtrArray *positions = event_viewer_data->pos;
1283
1284   for(i=0;i<positions->len;i++) {
1285     LttvTracesetContextPosition *cur_pos =
1286       (LttvTracesetContextPosition*)g_ptr_array_index(positions, i);
1287     if(lttv_traceset_context_pos_pos_compare(cur_pos,
1288           event_viewer_data->currently_selected_position) == 0) {
1289       GtkTreePath *path = gtk_tree_path_new_from_indices(i, -1);
1290       gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
1291                              path, NULL, FALSE);
1292       gtk_tree_path_free(path);
1293     }
1294   }
1295 }
1296
1297
1298 gboolean update_current_time(void * hook_data, void * call_data)
1299 {
1300   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1301   const LttTime * current_time = (LttTime*)call_data;
1302   LttvTracesetContext * tsc =
1303         lttvwindow_get_traceset_context(event_viewer_data->tab);
1304   GtkTreePath *path;
1305
1306   /* If the currently selected event time != current time, set the first event
1307    * with this time as currently selected. */
1308   LttTime pos_time = lttv_traceset_context_position_get_time(
1309       event_viewer_data->currently_selected_position);
1310   if(ltt_time_compare(pos_time, *current_time) != 0) {
1311
1312     lttv_process_traceset_seek_time(tsc, *current_time);
1313     lttv_traceset_context_position_save(tsc,
1314         event_viewer_data->currently_selected_position);
1315     pos_time = lttv_traceset_context_position_get_time(
1316         event_viewer_data->currently_selected_position);
1317   }
1318
1319   LttTime time = ltt_time_sub(pos_time, tsc->time_span.start_time);
1320   double new_value = ltt_time_to_double(time);
1321
1322   /* Change the viewed area if does not match */
1323   if(lttv_traceset_context_pos_pos_compare(
1324         event_viewer_data->currently_selected_position,
1325         event_viewer_data->first_event) < 0
1326     ||
1327      lttv_traceset_context_pos_pos_compare(
1328         event_viewer_data->currently_selected_position,
1329         event_viewer_data->last_event) > 0) {
1330     gtk_adjustment_set_value(event_viewer_data->vadjust_c, new_value);
1331   } else {
1332       /* Simply update the current time : it is in the list */
1333       event_update_selection(event_viewer_data);
1334   }
1335
1336   return FALSE;
1337 }
1338
1339 gboolean update_current_position(void * hook_data, void * call_data)
1340 {
1341   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1342   const LttvTracesetContextPosition *current_pos =
1343     (LttvTracesetContextPosition*)call_data;
1344   LttvTracesetContext * tsc =
1345         lttvwindow_get_traceset_context(event_viewer_data->tab);
1346
1347   if(lttv_traceset_context_pos_pos_compare(
1348         event_viewer_data->currently_selected_position, current_pos) != 0) {
1349     lttv_traceset_context_position_copy(
1350         event_viewer_data->currently_selected_position, current_pos);
1351
1352
1353     /* Change the viewed area if does not match */
1354     if(lttv_traceset_context_pos_pos_compare(
1355           event_viewer_data->currently_selected_position,
1356           event_viewer_data->first_event) < 0
1357       ||
1358        lttv_traceset_context_pos_pos_compare(
1359           event_viewer_data->currently_selected_position,
1360           event_viewer_data->last_event) > 0) {
1361       LttTime time = lttv_traceset_context_position_get_time(current_pos);
1362       time = ltt_time_sub(time, tsc->time_span.start_time);
1363       double new_value = ltt_time_to_double(time);
1364       gtk_adjustment_set_value(event_viewer_data->vadjust_c, new_value);
1365     } else {
1366       /* Simply update the current time : it is in the list */
1367       event_update_selection(event_viewer_data);
1368     }
1369
1370   }
1371
1372
1373   return FALSE;
1374 }
1375
1376
1377
1378 gboolean traceset_changed(void * hook_data, void * call_data)
1379 {
1380   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1381   LttvTracesetContext * tsc =
1382         lttvwindow_get_traceset_context(event_viewer_data->tab);
1383   TimeInterval time_span = tsc->time_span;
1384
1385   LttTime end;
1386   gtk_list_store_clear(event_viewer_data->store_m);
1387   g_ptr_array_set_size(event_viewer_data->pos, 0);
1388
1389   end = ltt_time_sub(time_span.end_time, time_span.start_time);
1390   event_viewer_data->vadjust_c->upper = ltt_time_to_double(end);
1391
1392   /* Reset the positions */
1393   lttv_traceset_context_position_destroy(
1394       event_viewer_data->currently_selected_position);
1395   lttv_traceset_context_position_destroy(
1396       event_viewer_data->first_event);
1397   lttv_traceset_context_position_destroy(
1398       event_viewer_data->last_event);
1399
1400   event_viewer_data->currently_selected_position =
1401     lttv_traceset_context_position_new(tsc);
1402   event_viewer_data->first_event =
1403     lttv_traceset_context_position_new(tsc);
1404   event_viewer_data->last_event =
1405     lttv_traceset_context_position_new(tsc);
1406
1407   get_events(event_viewer_data->vadjust_c->value, event_viewer_data);
1408   //  event_viewer_data->vadjust_c->value = 0;
1409
1410   return FALSE;
1411 }
1412
1413 gboolean filter_changed(void * hook_data, void * call_data)
1414 {
1415   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1416   LttvTracesetContext * tsc =
1417         lttvwindow_get_traceset_context(event_viewer_data->tab);
1418
1419   event_viewer_data->main_win_filter =
1420     (LttvFilter*)call_data;
1421   get_events(event_viewer_data->vadjust_c->value, event_viewer_data);
1422
1423   return FALSE;
1424 }
1425
1426
1427
1428
1429
1430 void gui_events_free(EventViewerData *event_viewer_data)
1431 {
1432   Tab *tab = event_viewer_data->tab;
1433   guint i;
1434
1435   if(event_viewer_data){
1436     lttv_hooks_remove(event_viewer_data->event_hooks,event_hook);
1437     lttv_hooks_destroy(event_viewer_data->event_hooks);
1438
1439     for(i=0;i<event_viewer_data->pos->len;i++) {
1440       LttvTracesetContextPosition *cur_pos =
1441         (LttvTracesetContextPosition*)g_ptr_array_index(event_viewer_data->pos,
1442                                                         i);
1443       lttv_traceset_context_position_destroy(cur_pos);
1444     }
1445     lttv_traceset_context_position_destroy(
1446         event_viewer_data->currently_selected_position);
1447     lttv_traceset_context_position_destroy(
1448         event_viewer_data->first_event);
1449     lttv_traceset_context_position_destroy(
1450         event_viewer_data->last_event);
1451     g_ptr_array_free(event_viewer_data->pos, TRUE);
1452
1453     lttvwindow_unregister_current_time_notify(tab,
1454                         update_current_time, event_viewer_data);
1455     lttvwindow_unregister_current_position_notify(tab,
1456                         update_current_position, event_viewer_data);
1457     //lttvwindow_unregister_show_notify(tab,
1458     //                    show_event_detail, event_viewer_data);
1459     lttvwindow_unregister_traceset_notify(tab,
1460                         traceset_changed, event_viewer_data);
1461     lttvwindow_unregister_filter_notify(tab,
1462                         filter_changed, event_viewer_data);
1463
1464     g_event_viewer_data_list = g_slist_remove(g_event_viewer_data_list,
1465         event_viewer_data);
1466     g_free(event_viewer_data);
1467   }
1468 }
1469
1470
1471
1472 void gui_events_destructor(EventViewerData *event_viewer_data)
1473 {
1474   /* May already been done by GTK window closing */
1475   if(GTK_IS_WIDGET(event_viewer_data->hbox_v)){
1476     gtk_widget_destroy(event_viewer_data->hbox_v);
1477   }
1478 }
1479
1480
1481
1482 /**
1483  * plugin's init function
1484  *
1485  * This function initializes the Event Viewer functionnality through the
1486  * gtkTraceSet API.
1487  */
1488 static void init() {
1489
1490   lttvwindow_register_constructor("guievents",
1491                                   "/",
1492                                   "Insert Event Viewer",
1493                                   hGuiEventsInsert_xpm,
1494                                   "Insert Event Viewer",
1495                                   h_gui_events);
1496 }
1497
1498 void event_destroy_walk(gpointer data, gpointer user_data)
1499 {
1500   gui_events_destructor((EventViewerData*)data);
1501 }
1502
1503 /**
1504  * plugin's destroy function
1505  *
1506  * This function releases the memory reserved by the module and unregisters
1507  * everything that has been registered in the gtkTraceSet API.
1508  */
1509 static void destroy() {
1510
1511   g_slist_foreach(g_event_viewer_data_list, event_destroy_walk, NULL );
1512   g_slist_free(g_event_viewer_data_list);
1513
1514   lttvwindow_unregister_constructor(h_gui_events);
1515
1516 }
1517
1518
1519
1520
1521 LTTV_MODULE("guievents", "Detailed events view", \
1522     "Graphical module to display a detailed event list", \
1523             init, destroy, "lttvwindow", "print")