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