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