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 *hbox_v;
 107   /* Widget to display the data in a columned list */
 108   GtkWidget *tree_v;
 109   GtkAdjustment *vtree_adjust_c ;
 110   GtkWidget *button; /* a button of the header, used to get the header_height */
 111   gint header_height;
 112
 113   /* Vertical scrollbar and its adjustment */
 114   GtkWidget *vscroll_vc;
 115   GtkAdjustment *vadjust_c;
 116
 117   /* Selection handler */
 118   GtkTreeSelection *select_c;
 119
 120   gint num_visible_events;
 121
 122   gint currently_selected_event;
 123
 124 } EventViewerData ;
 125
 126 /** hook functions for update time interval, current time ... */
 127 gboolean update_current_time(void * hook_data, void * call_data);
 128 //gboolean show_event_detail(void * hook_data, void * call_data);
 129 gboolean traceset_changed(void * hook_data, void * call_data);
 130
 131 //! Event Viewer's constructor hook
 132 GtkWidget *h_gui_events(Tab *tab);
 133 //! Event Viewer's constructor
 134 EventViewerData *gui_events(Tab *tab);
 135 //! Event Viewer's destructor
 136 void gui_events_destructor(EventViewerData *event_viewer_data);
 137 void gui_events_free(EventViewerData *event_viewer_data);
 138
 139 static gboolean
 140 header_size_allocate(GtkWidget *widget,
 141                         GtkAllocation *allocation,
 142                         gpointer user_data);
 143
 144 void tree_v_set_cursor(EventViewerData *event_viewer_data);
 145 void tree_v_get_cursor(EventViewerData *event_viewer_data);
 146
 147 /* Prototype for selection handler callback */
 148 static void tree_selection_changed_cb (GtkTreeSelection *selection,
 149     gpointer data);
 150 static void v_scroll_cb (GtkAdjustment *adjustment, gpointer data);
 151 static void tree_v_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc,
 152     gpointer data);
 153 static void tree_v_size_request_cb (GtkWidget *widget,
 154     GtkRequisition *requisition, gpointer data);
 155 static void tree_v_cursor_changed_cb (GtkWidget *widget, gpointer data);
 156 static void tree_v_move_cursor_cb (GtkWidget *widget, GtkMovementStep arg1,
 157     gint arg2, gpointer data);
 158
 159
 160 static void get_events(double time, EventViewerData *event_viewer_data);
 161
 162 int event_hook(void *hook_data, void *call_data);
 163
 164 /* Enumeration of the columns */
 165 enum
 166 {
 167   TRACE_NAME_COLUMN,
 168   TRACEFILE_NAME_COLUMN,
 169   CPUID_COLUMN,
 170   EVENT_COLUMN,
 171   FACILITY_COLUMN,
 172   TIME_S_COLUMN,
 173   TIME_NS_COLUMN,
 174   PID_COLUMN,
 175   EVENT_DESCR_COLUMN,
 176   POSITION_COLUMN,
 177   N_COLUMNS
 178 };
 179
 180 /**
 181  * Event Viewer's constructor hook
 182  *
 183  * This constructor is given as a parameter to the menuitem and toolbar button
 184  * registration. It creates the list.
 185  * @param parent_window A pointer to the parent window.
 186  * @return The widget created.
 187  */
 188 GtkWidget *
 189 h_gui_events(Tab * tab)
 190 {
 191   EventViewerData* event_viewer_data = gui_events(tab) ;
 192   if(event_viewer_data)
 193     return event_viewer_data->hbox_v;
 194   else return NULL;
 195
 196 }
 197
 198 /**
 199  * Event Viewer's constructor
 200  *
 201  * This constructor is used to create EventViewerData data structure.
 202  * @return The Event viewer data created.
 203  */
 204 EventViewerData *
 205 gui_events(Tab *tab)
 206 {
 207   LttTime end;
 208   GtkTreeViewColumn *column;
 209   GtkCellRenderer *renderer;
 210   EventViewerData* event_viewer_data = g_new(EventViewerData,1) ;
 211
 212   event_viewer_data->tab = tab;
 213
 214   event_viewer_data->event_hooks = lttv_hooks_new();
 215   lttv_hooks_add(event_viewer_data->event_hooks,
 216                  event_hook,
 217                  event_viewer_data,
 218                  LTTV_PRIO_DEFAULT);
 219
 220   lttvwindow_register_current_time_notify(tab,
 221                 update_current_time,event_viewer_data);
 222   lttvwindow_register_traceset_notify(tab,
 223                 traceset_changed,event_viewer_data);
 224
 225   event_viewer_data->scroll_win = gtk_scrolled_window_new (NULL, NULL);
 226   gtk_widget_show (event_viewer_data->scroll_win);
 227   gtk_scrolled_window_set_policy(
 228       GTK_SCROLLED_WINDOW(event_viewer_data->scroll_win),
 229       GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
 230
 231   event_viewer_data->currently_selected_event = -1;
 232
 233   /* Create a model for storing the data list */
 234   event_viewer_data->store_m = gtk_list_store_new (
 235     N_COLUMNS,      /* Total number of columns     */
 236     G_TYPE_STRING,  /* Trace name                  */
 237     G_TYPE_STRING,  /* Tracefile name              */
 238     G_TYPE_UINT,    /* CPUID                       */
 239     G_TYPE_STRING,  /* Event                       */
 240     G_TYPE_STRING,  /* Facility                    */
 241     G_TYPE_UINT,    /* Time s                      */
 242     G_TYPE_UINT,    /* Time ns                     */
 243     G_TYPE_INT,     /* PID                         */
 244     G_TYPE_STRING,  /* Event's description         */
 245     G_TYPE_POINTER);/* Position (not shown)        */
 246
 247   event_viewer_data->pos = g_ptr_array_sized_new(10);
 248
 249   /* Create the viewer widget for the columned list */
 250   event_viewer_data->tree_v =
 251     gtk_tree_view_new_with_model (GTK_TREE_MODEL (event_viewer_data->store_m));
 252
 253   g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "size-allocate",
 254         G_CALLBACK (tree_v_size_allocate_cb),
 255         event_viewer_data);
 256   g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "size-request",
 257         G_CALLBACK (tree_v_size_request_cb),
 258         event_viewer_data);
 259
 260   g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "cursor-changed",
 261         G_CALLBACK (tree_v_cursor_changed_cb),
 262         event_viewer_data);
 263
 264   g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "move-cursor",
 265         G_CALLBACK (tree_v_move_cursor_cb),
 266         event_viewer_data);
 267
 268   // Use on each column!
 269   //gtk_tree_view_column_set_sizing(event_viewer_data->tree_v,
 270   //GTK_TREE_VIEW_COLUMN_FIXED);
 271
 272   /* The view now holds a reference.  We can get rid of our own
 273    * reference */
 274   g_object_unref (G_OBJECT (event_viewer_data->store_m));
 275
 276
 277   /* Create a column, associating the "text" attribute of the
 278    * cell_renderer to the first column of the model */
 279   /* Columns alignment : 0.0 : Left    0.5 : Center   1.0 : Right */
 280   renderer = gtk_cell_renderer_text_new ();
 281   column = gtk_tree_view_column_new_with_attributes ("Trace",
 282                  renderer,
 283                  "text", TRACE_NAME_COLUMN,
 284                  NULL);
 285   gtk_tree_view_column_set_alignment (column, 0.0);
 286   gtk_tree_view_column_set_fixed_width (column, 120);
 287   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 288       column);
 289
 290   event_viewer_data->button = column->button;
 291
 292   g_signal_connect (G_OBJECT(event_viewer_data->button),
 293         "size-allocate",
 294         G_CALLBACK(header_size_allocate),
 295         (gpointer)event_viewer_data);
 296
 297
 298
 299   renderer = gtk_cell_renderer_text_new ();
 300   column = gtk_tree_view_column_new_with_attributes ("Tracefile",
 301                  renderer,
 302                  "text", TRACEFILE_NAME_COLUMN,
 303                  NULL);
 304   gtk_tree_view_column_set_alignment (column, 0.0);
 305   gtk_tree_view_column_set_fixed_width (column, 120);
 306   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 307       column);
 308
 309
 310   renderer = gtk_cell_renderer_text_new ();
 311   column = gtk_tree_view_column_new_with_attributes ("CPUID",
 312                  renderer,
 313                  "text", CPUID_COLUMN,
 314                  NULL);
 315   gtk_tree_view_column_set_alignment (column, 0.0);
 316   gtk_tree_view_column_set_fixed_width (column, 45);
 317   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 318       column);
 319
 320   renderer = gtk_cell_renderer_text_new ();
 321   column = gtk_tree_view_column_new_with_attributes ("Event",
 322                  renderer,
 323                  "text", EVENT_COLUMN,
 324                  NULL);
 325   gtk_tree_view_column_set_alignment (column, 0.0);
 326   gtk_tree_view_column_set_fixed_width (column, 120);
 327   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 328       column);
 329
 330   renderer = gtk_cell_renderer_text_new ();
 331   column = gtk_tree_view_column_new_with_attributes ("Facility",
 332                  renderer,
 333                  "text", FACILITY_COLUMN,
 334                  NULL);
 335   gtk_tree_view_column_set_alignment (column, 0.0);
 336   gtk_tree_view_column_set_fixed_width (column, 120);
 337   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 338       column);
 339
 340   renderer = gtk_cell_renderer_text_new ();
 341   column = gtk_tree_view_column_new_with_attributes ("Time (s)",
 342                  renderer,
 343                  "text", TIME_S_COLUMN,
 344                  NULL);
 345   gtk_tree_view_column_set_alignment (column, 1.0);
 346   gtk_tree_view_column_set_fixed_width (column, 120);
 347   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 348       column);
 349
 350   renderer = gtk_cell_renderer_text_new ();
 351   column = gtk_tree_view_column_new_with_attributes ("Time (ns)",
 352                  renderer,
 353                  "text", TIME_NS_COLUMN,
 354                  NULL);
 355   gtk_tree_view_column_set_alignment (column, 1.0);
 356   gtk_tree_view_column_set_fixed_width (column, 120);
 357   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 358       column);
 359
 360
 361   renderer = gtk_cell_renderer_text_new ();
 362   column = gtk_tree_view_column_new_with_attributes ("PID",
 363                  renderer,
 364                  "text", PID_COLUMN,
 365                  NULL);
 366   gtk_tree_view_column_set_alignment (column, 1.0);
 367   gtk_tree_view_column_set_fixed_width (column, 45);
 368   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 369       column);
 370
 371   renderer = gtk_cell_renderer_text_new ();
 372   column = gtk_tree_view_column_new_with_attributes ("Event Description",
 373                  renderer,
 374                  "text", EVENT_DESCR_COLUMN,
 375                  NULL);
 376   gtk_tree_view_column_set_alignment (column, 0.0);
 377   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
 378       column);
 379
 380
 381   /* Setup the selection handler */
 382   event_viewer_data->select_c =
 383     gtk_tree_view_get_selection (GTK_TREE_VIEW (event_viewer_data->tree_v));
 384   gtk_tree_selection_set_mode (event_viewer_data->select_c,
 385       GTK_SELECTION_SINGLE);
 386   g_signal_connect (G_OBJECT (event_viewer_data->select_c), "changed",
 387         G_CALLBACK (tree_selection_changed_cb),
 388         event_viewer_data);
 389
 390   gtk_container_add (GTK_CONTAINER (event_viewer_data->scroll_win),
 391       event_viewer_data->tree_v);
 392
 393   event_viewer_data->hbox_v = gtk_hbox_new(0, 0);
 394   gtk_box_pack_start(GTK_BOX(event_viewer_data->hbox_v),
 395       event_viewer_data->scroll_win, TRUE, TRUE, 0);
 396
 397   /* Create vertical scrollbar and pack it */
 398   event_viewer_data->vscroll_vc = gtk_vscrollbar_new(NULL);
 399   gtk_range_set_update_policy (GTK_RANGE(event_viewer_data->vscroll_vc),
 400              GTK_UPDATE_CONTINUOUS);
 401              // Changed by MD : more user friendly :)
 402              //GTK_UPDATE_DISCONTINUOUS);
 403   gtk_box_pack_start(GTK_BOX(event_viewer_data->hbox_v),
 404       event_viewer_data->vscroll_vc, FALSE, TRUE, 0);
 405
 406   /* Get the vertical scrollbar's adjustment */
 407   event_viewer_data->vadjust_c =
 408     gtk_range_get_adjustment(GTK_RANGE(event_viewer_data->vscroll_vc));
 409   event_viewer_data->vtree_adjust_c = gtk_tree_view_get_vadjustment(
 410                     GTK_TREE_VIEW (event_viewer_data->tree_v));
 411
 412   g_signal_connect (G_OBJECT (event_viewer_data->vadjust_c), "value-changed",
 413         G_CALLBACK (v_scroll_cb),
 414         event_viewer_data);
 415   /* Set the upper bound to the last event number */
 416   event_viewer_data->previous_value = 0;
 417   event_viewer_data->vadjust_c->lower = 0.0;
 418     //event_viewer_data->vadjust_c->upper = event_viewer_data->number_of_events;
 419   event_viewer_data->vadjust_c->value = 0.0;
 420   event_viewer_data->vadjust_c->step_increment = 1.0;
 421   event_viewer_data->vadjust_c->page_increment = 2.0;
 422     //  event_viewer_data->vtree_adjust_c->upper;
 423   event_viewer_data->vadjust_c->page_size = 2.0;
 424   //    event_viewer_data->vtree_adjust_c->upper;
 425   /*  Raw event trace */
 426   gtk_widget_show(event_viewer_data->hbox_v);
 427   gtk_widget_show(event_viewer_data->tree_v);
 428   gtk_widget_show(event_viewer_data->vscroll_vc);
 429
 430   /* Add the object's information to the module's array */
 431   g_event_viewer_data_list = g_slist_append(g_event_viewer_data_list,
 432       event_viewer_data);
 433
 434   event_viewer_data->num_visible_events = 1;
 435
 436   //get the life span of the traceset and set the upper of the scroll bar
 437
 438   LttvTracesetContext * tsc =
 439         lttvwindow_get_traceset_context(event_viewer_data->tab);
 440   TimeInterval time_span = tsc->time_span;
 441   end = ltt_time_sub(time_span.end_time, time_span.start_time);
 442
 443   event_viewer_data->vadjust_c->upper =
 444               ltt_time_to_double(end);
 445
 446   /* Set the Selected Event */
 447   //  tree_v_set_cursor(event_viewer_data);
 448
 449  // event_viewer_data->current_time_updated = FALSE;
 450  //
 451   g_object_set_data_full(
 452       G_OBJECT(event_viewer_data->hbox_v),
 453       "event_viewer_data",
 454       event_viewer_data,
 455       (GDestroyNotify)gui_events_free);
 456
 457
 458   return event_viewer_data;
 459 }
 460
 461
 462
 463 static gboolean
 464 header_size_allocate(GtkWidget *widget,
 465                         GtkAllocation *allocation,
 466                         gpointer user_data)
 467 {
 468   EventViewerData *event_viewer_data = (EventViewerData*)user_data;
 469
 470   event_viewer_data->header_height = allocation->height;
 471
 472   return 0;
 473 }
 474
 475
 476 void tree_v_set_cursor(EventViewerData *event_viewer_data)
 477 {
 478   GtkTreePath *path;
 479
 480   if(event_viewer_data->currently_selected_event != -1)
 481     {
 482       path = gtk_tree_path_new_from_indices(
 483               event_viewer_data->currently_selected_event,
 484               -1);
 485
 486       gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 487           path, NULL, FALSE);
 488       gtk_tree_path_free(path);
 489     }
 490 }
 491
 492 void tree_v_get_cursor(EventViewerData *event_viewer_data)
 493 {
 494   GtkTreePath *path;
 495   gint *indices;
 496
 497   gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 498       &path, NULL);
 499   indices = gtk_tree_path_get_indices(path);
 500
 501   if(indices != NULL)
 502       event_viewer_data->currently_selected_event = indices[0];
 503     else
 504       event_viewer_data->currently_selected_event = -1;
 505
 506   gtk_tree_path_free(path);
 507
 508 }
 509
 510
 511
 512 void tree_v_move_cursor_cb (GtkWidget *widget,
 513                             GtkMovementStep arg1,
 514                             gint arg2,
 515                             gpointer data)
 516 {
 517   GtkTreePath *path; // = gtk_tree_path_new();
 518   gint *indices;
 519   gdouble value;
 520   EventViewerData *event_viewer_data = (EventViewerData*)data;
 521
 522   gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 523                             &path, NULL);
 524   if(path == NULL)
 525   {
 526     /* No prior cursor, put it at beginning of page
 527      * and let the execution do */
 528     path = gtk_tree_path_new_from_indices(0, -1);
 529     gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 530                                 path, NULL, FALSE);
 531   }
 532
 533   indices = gtk_tree_path_get_indices(path);
 534
 535   value = gtk_adjustment_get_value(event_viewer_data->vadjust_c);
 536
 537   g_debug("tree view move cursor : arg1 is %u and arg2 is %d",
 538       (guint)arg1, arg2);
 539
 540 #if 0
 541   if(arg1 == GTK_MOVEMENT_DISPLAY_LINES)
 542   {
 543     /* Move one line */
 544     if(arg2 == 1)
 545     {
 546       /* move one line down */
 547       if(indices[0]) // Do we need an empty field here (before first)?
 548       {
 549         if(value + event_viewer_data->num_visible_events <=
 550             event_viewer_data->number_of_events -1)
 551         {
 552           event_viewer_data->currently_selected_event += 1;
 553           //      gtk_adjustment_set_value(event_viewer_data->vadjust_c, value+1);
 554           //gtk_tree_path_free(path);
 555           //path = gtk_tree_path_new_from_indices(event_viewer_data->num_visible_events-1, -1);
 556           //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 557           g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 558         }
 559       }
 560     } else {
 561       /* Move one line up */
 562       if(indices[0] == 0)
 563       {
 564         if(value - 1 >= 0 )
 565         {
 566           event_viewer_data->currently_selected_event -= 1;
 567           //      gtk_adjustment_set_value(event_viewer_data->vadjust_c, value-1);
 568           //gtk_tree_path_free(path);
 569           //path = gtk_tree_path_new_from_indices(0, -1);
 570           //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 571           g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 572         }
 573       }
 574     }
 575   }
 576
 577   if(arg1 == GTK_MOVEMENT_PAGES)
 578   {
 579     /* Move one page */
 580     if(arg2 == 1)
 581     {
 582       if(event_viewer_data->num_visible_events == 1)
 583         value += 1 ;
 584       /* move one page down */
 585       if(value + event_viewer_data->num_visible_events-1 <=
 586                       event_viewer_data->number_of_events )
 587       {
 588         event_viewer_data->currently_selected_event +=
 589                                   event_viewer_data->num_visible_events-1;
 590         //        gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 591         //               value+(event_viewer_data->num_visible_events-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     } else {
 598       /* Move one page up */
 599       if(event_viewer_data->num_visible_events == 1)
 600         value -= 1 ;
 601
 602       if(indices[0] < event_viewer_data->num_visible_events - 2 )
 603       {
 604         if(value - (event_viewer_data->num_visible_events-1) >= 0)
 605         {
 606           event_viewer_data->currently_selected_event -=
 607                           event_viewer_data->num_visible_events-1;
 608
 609           //      gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 610           //             value-(event_viewer_data->num_visible_events-1));
 611           //gtk_tree_path_free(path);
 612           //path = gtk_tree_path_new_from_indices(0, -1);
 613           //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 614           g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 615
 616         } else {
 617           /* Go to first Event */
 618           event_viewer_data->currently_selected_event == 0 ;
 619           //      gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 620           //             0);
 621           //gtk_tree_path_free(path);
 622           //path = gtk_tree_path_new_from_indices(0, -1);
 623           //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 624           g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 625
 626         }
 627       }
 628     }
 629   }
 630
 631   if(arg1 == GTK_MOVEMENT_BUFFER_ENDS)
 632   {
 633     /* Move to the ends of the buffer */
 634     if(arg2 == 1)
 635     {
 636       /* move end of buffer */
 637       event_viewer_data->currently_selected_event =
 638                             event_viewer_data->number_of_events-1 ;
 639       //    gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 640       //           event_viewer_data->number_of_events -
 641       //           event_viewer_data->num_visible_events);
 642       //gtk_tree_path_free(path);
 643       //path = gtk_tree_path_new_from_indices(event_viewer_data->num_visible_events-1, -1);
 644       //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 645       g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 646     } else {
 647       /* Move beginning of buffer */
 648       event_viewer_data->currently_selected_event = 0 ;
 649       //    gtk_adjustment_set_value(event_viewer_data->vadjust_c, 0);
 650         //gtk_tree_path_free(path);
 651         //path = gtk_tree_path_new_from_indices(0, -1);
 652         //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 653       g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 654     }
 655   }
 656 #endif //0
 657   gtk_tree_path_free(path);
 658 }
 659
 660 void tree_v_cursor_changed_cb (GtkWidget *widget, gpointer data)
 661 {
 662   EventViewerData *event_viewer_data = (EventViewerData*) data;
 663   Tab *tab = event_viewer_data->tab;
 664   GtkTreeIter iter;
 665   GtkTreeModel* model = GTK_TREE_MODEL(event_viewer_data->store_m);
 666   GtkTreePath *path;
 667   LttvTracesetContextPosition *pos;
 668
 669
 670   /* On cursor change, modify the currently selected event by calling
 671    * the right API function */
 672   tree_v_get_cursor(event_viewer_data);
 673
 674   gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
 675       &path, NULL);
 676   if(gtk_tree_model_get_iter(model,&iter,path)){
 677     gtk_tree_model_get(model, &iter, POSITION_COLUMN, &pos, -1);
 678
 679     lttvwindow_report_current_position(tab, pos);
 680   }else{
 681     g_warning("Can not get iter\n");
 682   }
 683
 684 }
 685
 686
 687 void v_scroll_cb (GtkAdjustment *adjustment, gpointer data)
 688 {
 689   EventViewerData *event_viewer_data = (EventViewerData*)data;
 690   GtkTreePath *tree_path;
 691
 692   get_events(adjustment->value, event_viewer_data);
 693
 694   if(event_viewer_data->currently_selected_event != -1) {
 695
 696       tree_path = gtk_tree_path_new_from_indices(
 697              event_viewer_data->currently_selected_event,
 698              -1);
 699
 700       //      gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), tree_path,
 701       //             NULL, FALSE);
 702       gtk_tree_path_free(tree_path);
 703   }
 704 }
 705
 706 static __inline gint get_cell_height(GtkTreeView *TreeView)
 707 {
 708   gint height;
 709   GtkTreeViewColumn *column = gtk_tree_view_get_column(TreeView, 0);
 710
 711   gtk_tree_view_column_cell_get_size(column, NULL, NULL, NULL, NULL, &height);
 712
 713   return height;
 714 }
 715
 716 void tree_v_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data)
 717 {
 718   EventViewerData *event_viewer_data = (EventViewerData*)data;
 719   gint cell_height = get_cell_height(GTK_TREE_VIEW(event_viewer_data->tree_v));
 720   gint last_num_visible_events = event_viewer_data->num_visible_events;
 721   gdouble exact_num_visible;
 722
 723   exact_num_visible = ( alloc->height -
 724           event_viewer_data->header_height )
 725             / (double)cell_height ;
 726
 727   event_viewer_data->num_visible_events = ceil(exact_num_visible) ;
 728
 729 /*
 730   event_viewer_data->vadjust_c->page_increment =
 731     floor(exact_num_visible);
 732   event_viewer_data->vadjust_c->page_size =
 733     floor(exact_num_visible);
 734 */
 735
 736   g_debug("size allocate : last_num_visible_events : %d,\
 737            num_visible_events : %d",
 738            last_num_visible_events,
 739            event_viewer_data->num_visible_events);
 740   if(event_viewer_data->num_visible_events != last_num_visible_events)
 741     {
 742       get_events(event_viewer_data->vadjust_c->value, event_viewer_data);
 743     }
 744
 745
 746 }
 747
 748 void tree_v_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data)
 749 {
 750   gint h;
 751   EventViewerData *event_viewer_data = (EventViewerData*)data;
 752   gint cell_height = get_cell_height(GTK_TREE_VIEW(event_viewer_data->tree_v));
 753
 754   h = cell_height + event_viewer_data->header_height;
 755   requisition->height = h;
 756
 757 }
 758
 759 #if 0
 760 gboolean show_event_detail(void * hook_data, void * call_data)
 761 {
 762   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
 763   LttvTracesetContext * tsc = lttvwindow_get_traceset_context(event_viewer_data->tab);
 764
 765   if(event_viewer_data->event_fields_queue_tmp->length == 0 &&
 766      event_viewer_data->event_fields_queue->length == 0){
 767     event_viewer_data->shown = FALSE;
 768     return FALSE;
 769   }
 770
 771   if(event_viewer_data->shown == FALSE){
 772     event_viewer_data->shown = TRUE;
 773     update_raw_data_array(event_viewer_data,
 774         event_viewer_data->event_fields_queue_tmp->length);
 775
 776     get_data(event_viewer_data->vadjust_c->value,
 777       event_viewer_data->num_visible_events,
 778       event_viewer_data);
 779
 780     remove_context_hooks(event_viewer_data,tsc);
 781   }
 782
 783   return FALSE;
 784 }
 785 #endif //0
 786
 787
 788
 789
 790
 791
 792
 793 static void get_events(double new_value, EventViewerData *event_viewer_data)
 794 {
 795   LttvTracesetStats *tss =
 796     lttvwindow_get_traceset_stats(event_viewer_data->tab);
 797   LttvTracesetContext *tsc = (LttvTracesetContext*)tss;
 798   guint i;
 799
 800   double value = new_value - event_viewer_data->previous_value;
 801   event_viewer_data->previous_value = new_value;
 802
 803   /* See where we have to scroll... */
 804   ScrollDirection direction;
 805   gint relative_position;
 806
 807   if(value < 0.0) {
 808     if(value >= -1.0) direction = SCROLL_STEP_UP;
 809     else {
 810       if(value >= -2.0) direction = SCROLL_PAGE_UP;
 811       else direction = SCROLL_JUMP;
 812     }
 813   } else if(value > 0.0) {
 814     if(value <= 1.0) direction = SCROLL_STEP_DOWN;
 815     else {
 816       if(value <= 2.0) direction = SCROLL_PAGE_DOWN;
 817       else direction = SCROLL_JUMP;
 818     }
 819   } else direction = SCROLL_NONE; /* 0.0 */
 820
 821
 822   switch(direction) {
 823   case SCROLL_STEP_UP:
 824     g_debug("get_events : SCROLL_STEP_UP");
 825     relative_position = -1;
 826     break;
 827   case SCROLL_STEP_DOWN:
 828     g_debug("get_events : SCROLL_STEP_DOWN");
 829     relative_position = 1;
 830     break;
 831   case SCROLL_PAGE_UP:
 832     g_debug("get_events : SCROLL_PAGE_UP");
 833     relative_position = -(event_viewer_data->num_visible_events);
 834     break;
 835   case SCROLL_PAGE_DOWN:
 836     g_debug("get_events : SCROLL_PAGE_DOWN");
 837     relative_position = event_viewer_data->num_visible_events;
 838     break;
 839   case SCROLL_JUMP:
 840     g_debug("get_events : SCROLL_JUMP");
 841     relative_position = 0;
 842     break;
 843   case SCROLL_NONE:
 844     g_debug("get_events : SCROLL_NONE");
 845     goto end;
 846     break;
 847   }
 848
 849   LttTime time = ltt_time_from_double(new_value);
 850   time = ltt_time_add(tsc->time_span.start_time, time);
 851
 852   if(relative_position) {
 853
 854     LttvTracesetContextPosition *pos =
 855         lttv_traceset_context_position_new(tsc);
 856
 857   /* Remember the beginning position */
 858     if(event_viewer_data->pos->len > 0) {
 859       LttvTracesetContextPosition *first_pos =
 860         (LttvTracesetContextPosition*)g_ptr_array_index(event_viewer_data->pos,
 861                                                         0);
 862       lttv_traceset_context_position_copy(pos, first_pos);
 863       g_assert(lttv_process_traceset_seek_position(tsc, pos) == 0);
 864     } else {
 865       /* There is nothing in the list : simply seek to the time value. */
 866       lttv_state_traceset_seek_time_closest((LttvTracesetState*)tsc,
 867           time);
 868     }
 869
 870   /* Clear the model (don't forget to free the TCS positions!) */
 871     gtk_list_store_clear(event_viewer_data->store_m);
 872     for(i=0;i<event_viewer_data->pos->len;i++) {
 873       LttvTracesetContextPosition *cur_pos =
 874         (LttvTracesetContextPosition*)g_ptr_array_index(event_viewer_data->pos,
 875                                                         i);
 876       lttv_traceset_context_position_destroy(cur_pos);
 877     }
 878     g_ptr_array_set_size(event_viewer_data->pos, 0);
 879
 880   /* Note that, as we mess with the tsc position, this function CANNOT be called
 881    * from a hook inside the lttv_process_traceset_middle. */
 882   /* As the lttvwindow API keeps a sync_position inside the tsc to go back at
 883    * the right spot after being interrupted, it's ok to change the tsc position,
 884    * as long as we do not touch the sync_position. */
 885
 886   /* Get the beginning position of the read (with seek backward or seek forward)
 887    */
 888     if(relative_position > 0) {
 889       guint count;
 890       count = lttv_process_traceset_seek_n_forward(tsc, relative_position,
 891           lttvwindow_get_filter(event_viewer_data->tab));
 892     } else {  /* < 0 */
 893       guint count;
 894       count = lttv_process_traceset_seek_n_backward(tsc, abs(relative_position),
 895           seek_back_default_offset, lttv_process_traceset_seek_time,
 896           lttvwindow_get_filter(event_viewer_data->tab));
 897     }
 898
 899     lttv_traceset_context_position_destroy(pos);
 900   } else {
 901     /* Seek by time */
 902     lttv_state_traceset_seek_time_closest((LttvTracesetState*)tsc,
 903           time);
 904   }
 905
 906   /* Mathieu :
 907    * I make the choice not to use the mainwindow lttvwindow API here : it will
 908    * be faster to read the events ourself from lttv_process_traceset_middle, as
 909    * we are already at the right read position. It would be costier to use the
 910    * seek time closest for nothing, as we only have few events to read.
 911    */
 912   /* FIXME : use seek time closest and middle to have a good state. */
 913
 914   lttv_process_traceset_begin(tsc,
 915       NULL, NULL, NULL, event_viewer_data->event_hooks, NULL);
 916
 917   lttv_process_traceset_middle(tsc, ltt_time_infinite, G_MAXUINT, NULL);
 918
 919   lttv_process_traceset_end(tsc,
 920       NULL, NULL, NULL, event_viewer_data->event_hooks, NULL);
 921
 922 end:
 923   return;
 924 }
 925
 926
 927
 928 int event_hook(void *hook_data, void *call_data)
 929 {
 930   EventViewerData *event_viewer_data = (EventViewerData*)hook_data;
 931   LttvTracefileContext *tfc = (LttvTracefileContext*)call_data;
 932   LttEvent *e = ltt_tracefile_get_event(tfc->tf);
 933
 934   LttvFilter *filter = lttvwindow_get_filter(event_viewer_data->tab);
 935   if(filter != NULL && filter->head != NULL)
 936     if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
 937           tfc->t_context->t,tfc))
 938       return FALSE;
 939
 940   LttFacility *facility = ltt_event_facility(e);
 941   LttEventType *event_type = ltt_event_eventtype(e);
 942   LttField *field = ltt_event_field(e);
 943   LttTime time = ltt_event_time(e);
 944
 945   guint cpu = ltt_tracefile_num(tfc->tf);
 946   LttvTraceState *ts = (LttvTraceState*)tfc->t_context;
 947   LttvProcessState *process = ts->running_process[cpu];
 948
 949   GtkTreeIter iter;
 950
 951   GString *desc = g_string_new("");
 952
 953   LttvTracesetContextPosition *pos =
 954     lttv_traceset_context_position_new(tfc->t_context->ts_context);
 955
 956   lttv_traceset_context_position_save(tfc->t_context->ts_context, pos);
 957
 958   if(field)
 959     lttv_print_field(e, field, desc, TRUE);
 960
 961   g_info("field : %s", desc->str);
 962
 963   gtk_list_store_append (event_viewer_data->store_m, &iter);
 964   gtk_list_store_set (event_viewer_data->store_m, &iter,
 965       TRACE_NAME_COLUMN, g_quark_to_string(ltt_trace_name(tfc->t_context->t)),
 966       TRACEFILE_NAME_COLUMN, g_quark_to_string(ltt_tracefile_name(tfc->tf)),
 967       CPUID_COLUMN, cpu,
 968       FACILITY_COLUMN, g_quark_to_string(ltt_facility_name(facility)),
 969       EVENT_COLUMN, g_quark_to_string(ltt_eventtype_name(event_type)),
 970       TIME_S_COLUMN, time.tv_sec,
 971       TIME_NS_COLUMN, time.tv_nsec,
 972       PID_COLUMN, process->pid,
 973       EVENT_DESCR_COLUMN, desc->str,
 974       POSITION_COLUMN, pos,
 975       -1);
 976
 977   g_ptr_array_add(event_viewer_data->pos, pos);
 978
 979   g_string_free(desc, TRUE);
 980
 981   if(event_viewer_data->pos->len >= event_viewer_data->num_visible_events)
 982     return TRUE;
 983   else
 984     return FALSE;
 985 }
 986
 987
 988
 989
 990 gboolean update_current_time(void * hook_data, void * call_data)
 991 {
 992   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
 993   const LttTime * current_time = (LttTime*)call_data;
 994   LttvTracesetContext * tsc =
 995         lttvwindow_get_traceset_context(event_viewer_data->tab);
 996
 997   LttTime time = ltt_time_sub(*current_time, tsc->time_span.start_time);
 998   double new_value = ltt_time_to_double(time);
 999   GtkTreePath *path;
1000
1001   gtk_adjustment_set_value(event_viewer_data->vadjust_c, new_value);
1002
1003   event_viewer_data->currently_selected_event = 0;
1004
1005   path = gtk_tree_path_new_from_indices(
1006              event_viewer_data->currently_selected_event,
1007              -1);
1008   gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
1009   //g_signal_stop_emission_by_name(G_OBJECT(event_viewer_data->tree_v), "cursor-changed");
1010   gtk_tree_path_free(path);
1011
1012   return FALSE;
1013 }
1014
1015 gboolean traceset_changed(void * hook_data, void * call_data)
1016 {
1017   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1018   LttvTracesetContext * tsc =
1019         lttvwindow_get_traceset_context(event_viewer_data->tab);
1020   TimeInterval time_span = tsc->time_span;
1021
1022   LttTime end;
1023   gtk_list_store_clear(event_viewer_data->store_m);
1024   g_ptr_array_set_size(event_viewer_data->pos, 0);
1025
1026   end = ltt_time_sub(time_span.end_time, time_span.start_time);
1027   event_viewer_data->vadjust_c->upper = ltt_time_to_double(end);
1028   g_signal_emit_by_name(event_viewer_data->vadjust_c, "value-changed");
1029   //  event_viewer_data->vadjust_c->value = 0;
1030
1031   return FALSE;
1032 }
1033
1034
1035
1036
1037
1038 void gui_events_free(EventViewerData *event_viewer_data)
1039 {
1040   Tab *tab = event_viewer_data->tab;
1041   guint i;
1042
1043   if(event_viewer_data){
1044     lttv_hooks_remove(event_viewer_data->event_hooks,event_hook);
1045     lttv_hooks_destroy(event_viewer_data->event_hooks);
1046
1047     for(i=0;i<event_viewer_data->pos->len;i++) {
1048       LttvTracesetContextPosition *cur_pos =
1049         (LttvTracesetContextPosition*)g_ptr_array_index(event_viewer_data->pos,
1050                                                         i);
1051       lttv_traceset_context_position_destroy(cur_pos);
1052     }
1053     g_ptr_array_free(event_viewer_data->pos, TRUE);
1054
1055     lttvwindow_unregister_current_time_notify(tab,
1056                         update_current_time, event_viewer_data);
1057     //lttvwindow_unregister_show_notify(tab,
1058     //                    show_event_detail, event_viewer_data);
1059     lttvwindow_unregister_traceset_notify(tab,
1060                         traceset_changed, event_viewer_data);
1061
1062     g_event_viewer_data_list = g_slist_remove(g_event_viewer_data_list,
1063         event_viewer_data);
1064     g_free(event_viewer_data);
1065   }
1066 }
1067
1068
1069
1070 void gui_events_destructor(EventViewerData *event_viewer_data)
1071 {
1072   /* May already been done by GTK window closing */
1073   if(GTK_IS_WIDGET(event_viewer_data->hbox_v)){
1074     gtk_widget_destroy(event_viewer_data->hbox_v);
1075   }
1076 }
1077
1078
1079
1080 /**
1081  * plugin's init function
1082  *
1083  * This function initializes the Event Viewer functionnality through the
1084  * gtkTraceSet API.
1085  */
1086 static void init() {
1087
1088   lttvwindow_register_constructor("guievents",
1089                                   "/",
1090                                   "Insert Event Viewer",
1091                                   hGuiEventsInsert_xpm,
1092                                   "Insert Event Viewer",
1093                                   h_gui_events);
1094 }
1095
1096 void event_destroy_walk(gpointer data, gpointer user_data)
1097 {
1098   gui_events_destructor((EventViewerData*)data);
1099 }
1100
1101 /**
1102  * plugin's destroy function
1103  *
1104  * This function releases the memory reserved by the module and unregisters
1105  * everything that has been registered in the gtkTraceSet API.
1106  */
1107 static void destroy() {
1108
1109   g_slist_foreach(g_event_viewer_data_list, event_destroy_walk, NULL );
1110   g_slist_free(g_event_viewer_data_list);
1111
1112   lttvwindow_unregister_constructor(h_gui_events);
1113
1114 }
1115
1116
1117
1118
1119 LTTV_MODULE("guievents", "Detailed events view", \
1120     "Graphical module to display a detailed event list", \
1121             init, destroy, "lttvwindow", "print")