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