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