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