X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Fmodules%2FguiEvents.c;h=ec1e898a62c9dfe7901178a7579fe7f887634707;hb=fda16332eab0088d07b2269754af75aaa27e736f;hp=ca7cd1355b21f69f85b10e8c99ee948b4aafc945;hpb=cbd41522fece37839f38aaf3372b8a11fac9b267;p=lttv.git

diff --git a/ltt/branches/poly/lttv/modules/guiEvents.c b/ltt/branches/poly/lttv/modules/guiEvents.c
index ca7cd135..ec1e898a 100644
--- a/ltt/branches/poly/lttv/modules/guiEvents.c
+++ b/ltt/branches/poly/lttv/modules/guiEvents.c
@@ -41,6 +41,7 @@
 #include <ltt/event.h>
 #include <ltt/type.h>
 #include <ltt/trace.h>
+#include <ltt/facility.h>
 #include <string.h>
 
 //#include "mw_api.h"
@@ -54,12 +55,6 @@ static LttvHooks  *before_event;
 /** Array containing instanced objects. Used when module is unloaded */
 static GSList *g_event_viewer_data_list = NULL ;
 
-/** hook functions for update time interval, current time ... */
-gboolean update_time_window(void * hook_data, void * call_data);
-gboolean update_current_time(void * hook_data, void * call_data);
-void remove_item_from_queue(GQueue * q, gboolean fromHead);
-void remove_all_items_from_queue(GQueue * q);
-
 typedef struct _RawTraceData{
   unsigned  cpu_id;
   char * event_name;
@@ -67,11 +62,13 @@ typedef struct _RawTraceData{
   int pid;
   unsigned entry_length;
   char * event_description;
-  LttEventPosition ep;
+  LttEventPosition *ep;
 } RawTraceData;
 
-#define RESERVE_BIG_SIZE      1000
-#define RESERVE_SMALL_SIZE    100
+#define RESERVE_BIG_SIZE             1000
+#define RESERVE_SMALL_SIZE           100
+#define RESERVE_SMALL_SIZE_SQUARE    RESERVE_SMALL_SIZE*RESERVE_SMALL_SIZE
+#define RESERVE_SMALL_SIZE_CUBE      RESERVE_SMALL_SIZE*RESERVE_SMALL_SIZE_SQUARE
 
 typedef enum _ScrollDirection{
   SCROLL_STEP_UP,
@@ -95,10 +92,11 @@ typedef struct _EventViewerData {
   unsigned     current_event_index;
   double       previous_value;            //value of the slide
   TimeInterval time_span;
- // LttTime      trace_start;
- // LttTime      trace_end;
   unsigned     start_event_index;        //the first event shown in the window
   unsigned     end_event_index;          //the last event shown in the window
+  unsigned     size;                     //maxi number of events loaded when instance the viewer
+  gboolean     shown;                    //indicate if event detail is shown or not
+  char *       filter_key;
 
   //scroll window containing Tree View
   GtkWidget * scroll_win;
@@ -128,10 +126,22 @@ typedef struct _EventViewerData {
 
 } EventViewerData ;
 
+/** hook functions for update time interval, current time ... */
+gboolean update_time_window(void * hook_data, void * call_data);
+gboolean update_current_time(void * hook_data, void * call_data);
+gboolean show_event_detail(void * hook_data, void * call_data);
+gboolean traceset_changed(void * hook_data, void * call_data);
+void remove_item_from_queue(GQueue * q, gboolean fromHead);
+void remove_all_items_from_queue(GQueue * q);
+void add_context_hooks(EventViewerData * event_viewer_data, 
+		       LttvTracesetContext * tsc);
+void remove_context_hooks(EventViewerData * event_viewer_data, 
+			  LttvTracesetContext * tsc);
+
 //! Event Viewer's constructor hook
-GtkWidget *h_gui_events(MainWindow *parent_window);
+GtkWidget *h_gui_events(MainWindow *parent_window, LttvTracesetSelector * s, char* key);
 //! Event Viewer's constructor
-EventViewerData *gui_events(MainWindow *parent_window);
+EventViewerData *gui_events(MainWindow *parent_window, LttvTracesetSelector *s, char *key);
 //! Event Viewer's destructor
 void gui_events_destructor(EventViewerData *event_viewer_data);
 void gui_events_free(EventViewerData *event_viewer_data);
@@ -156,6 +166,8 @@ static void get_test_data(double time, guint list_height,
 
 void add_test_data(EventViewerData *event_viewer_data);
 
+static void update_raw_data_array(EventViewerData* event_viewer_data, unsigned size);
+
 static void get_events(EventViewerData* event_viewer_data, LttTime start, 
 		       LttTime end, unsigned max_num_events, unsigned * real_num_events);
 static gboolean parse_event(void *hook_data, void *call_data);
@@ -235,9 +247,9 @@ enum
  * @return The widget created.
  */
 GtkWidget *
-h_gui_events(MainWindow * parent_window)
+h_gui_events(MainWindow * parent_window, LttvTracesetSelector * s, char* key)
 {
-  EventViewerData* event_viewer_data = gui_events(parent_window) ;
+  EventViewerData* event_viewer_data = gui_events(parent_window, s, key) ;
 
   if(event_viewer_data)
     return event_viewer_data->hbox_v;
@@ -252,14 +264,13 @@ h_gui_events(MainWindow * parent_window)
  * @return The Event viewer data created.
  */
 EventViewerData *
-gui_events(MainWindow *parent_window)
+gui_events(MainWindow *parent_window, LttvTracesetSelector * s,char* key )
 {
   LttTime start, end;
   GtkTreeViewColumn *column;
   GtkCellRenderer *renderer;
   EventViewerData* event_viewer_data = g_new(EventViewerData,1) ;
   RawTraceData * data;
-  unsigned size;
 
   event_viewer_data->mw = parent_window;
   get_time_window(event_viewer_data->mw, &event_viewer_data->time_window);
@@ -273,6 +284,8 @@ gui_events(MainWindow *parent_window)
 
   reg_update_time_window(update_time_window,event_viewer_data, event_viewer_data->mw);
   reg_update_current_time(update_current_time,event_viewer_data, event_viewer_data->mw);
+  reg_show_viewer(show_event_detail,event_viewer_data, event_viewer_data->mw);
+  reg_update_traceset(traceset_changed,event_viewer_data, event_viewer_data->mw);
 
   event_viewer_data->scroll_win = gtk_scrolled_window_new (NULL, NULL);
   gtk_widget_show ( event_viewer_data->scroll_win);
@@ -437,25 +450,30 @@ gui_events(MainWindow *parent_window)
 
   event_viewer_data->append = TRUE;
 
-  start.tv_sec = 0;
-  start.tv_nsec = 0;
-  end.tv_sec = G_MAXULONG;
-  end.tv_nsec = G_MAXULONG;
-
-  get_events(event_viewer_data, start,end, RESERVE_SMALL_SIZE, &size);
-
   event_viewer_data->start_event_index = 0;
   event_viewer_data->end_event_index   = event_viewer_data->num_visible_events - 1;  
 
-  // Test data 
-  get_test_data(event_viewer_data->vadjust_c->value,
-		event_viewer_data->num_visible_events, 
-		event_viewer_data);
-
   /* Set the Selected Event */
   //  tree_v_set_cursor(event_viewer_data);
 
-
+  event_viewer_data->shown = FALSE;
+  event_viewer_data->size  = RESERVE_SMALL_SIZE;
+  g_object_set_data(
+		    G_OBJECT(event_viewer_data->hbox_v),
+		    MAX_NUMBER_EVENT,
+		    &event_viewer_data->size);
+  
+  g_object_set_data(
+		    G_OBJECT(event_viewer_data->hbox_v),
+		    TRACESET_TIME_SPAN,
+		    &event_viewer_data->time_span);
+
+  event_viewer_data->filter_key = g_strdup(key);
+  g_object_set_data(
+		    G_OBJECT(event_viewer_data->hbox_v),
+		    event_viewer_data->filter_key,
+		    s);
+  
   g_object_set_data_full(
 			G_OBJECT(event_viewer_data->hbox_v),
 			"event_viewer_data",
@@ -764,6 +782,55 @@ void tree_v_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpo
 	
 }
 
+gboolean show_event_detail(void * hook_data, void * call_data)
+{
+  EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
+  LttvTracesetContext * tsc = get_traceset_context(event_viewer_data->mw);
+
+  if(event_viewer_data->shown == FALSE){
+    event_viewer_data->shown = TRUE;
+    update_raw_data_array(event_viewer_data, 
+			  event_viewer_data->raw_trace_data_queue_tmp->length);
+
+    get_test_data(event_viewer_data->vadjust_c->value,
+		  event_viewer_data->num_visible_events, 
+		  event_viewer_data);
+
+    remove_context_hooks(event_viewer_data,tsc);
+  }
+
+  return FALSE;
+}
+
+void insert_data_into_model(EventViewerData *event_viewer_data, int start, int end)
+{
+  int i;
+  guint64 real_data;
+  RawTraceData * raw_data;
+  GList * first;
+  GtkTreeIter iter;
+
+  first = event_viewer_data->raw_trace_data_queue->head;
+  for(i=start; i<end; i++){
+    if(i>=event_viewer_data->number_of_events) break;    
+    raw_data = (RawTraceData*)g_list_nth_data(first, i);
+    
+    // Add a new row to the model 
+    real_data = raw_data->time.tv_sec;
+    real_data *= NANOSECONDS_PER_SECOND;
+    real_data += raw_data->time.tv_nsec;
+    gtk_list_store_append (event_viewer_data->store_m, &iter);
+    gtk_list_store_set (event_viewer_data->store_m, &iter,
+			CPUID_COLUMN, raw_data->cpu_id,
+			EVENT_COLUMN, raw_data->event_name,
+			TIME_COLUMN, real_data,
+			PID_COLUMN, raw_data->pid,
+			ENTRY_LEN_COLUMN, raw_data->entry_length,
+			EVENT_DESCR_COLUMN, raw_data->event_description,
+			-1);
+  }
+}
+
 void get_test_data(double time_value, guint list_height, 
 		   EventViewerData *event_viewer_data)
 {
@@ -783,8 +850,20 @@ void get_test_data(double time_value, guint list_height,
   unsigned  block_num, event_num;
   unsigned size = 1, count = 0;
   gboolean need_backward_again, backward;
-
+  GdkWindow * win;
+  GdkCursor * new;
+  GtkWidget* widget = gtk_widget_get_parent(event_viewer_data->hbox_v);
   
+  if(widget){
+    new = gdk_cursor_new(GDK_X_CURSOR);
+    win = gtk_widget_get_parent_window(widget);  
+    gdk_window_set_cursor(win, new);
+    gdk_cursor_unref(new);  
+    gdk_window_stick(win);
+    gdk_window_unstick(win);
+  }
+
+
   //	if(event_number > event_viewer_data->last_event ||
   //		 event_number + list_height-1 < event_viewer_data->first_event ||
   //		 event_viewer_data->first_event == -1)
@@ -815,42 +894,43 @@ void get_test_data(double time_value, guint list_height,
 	    }
 
 	    first = event_viewer_data->raw_trace_data_queue->head;
+	    if(!first)break;
 	    raw_data = (RawTraceData*)g_list_nth_data(first,0);
 	    end = raw_data->time;
 	    end.tv_nsec--;
-	    ltt_event_position_get(&raw_data->ep, &block_num, &event_num, &tf);
+	    ltt_event_position_get(raw_data->ep, &block_num, &event_num, &tf);
 	    if(size !=0){
 	      if(event_num > minNum){
 		backward_num = event_num > RESERVE_SMALL_SIZE 
 		              ? event_num - RESERVE_SMALL_SIZE : 1;
-		ltt_event_position_set(&raw_data->ep, block_num, backward_num);
-		ltt_tracefile_seek_position(tf, &raw_data->ep);
+		ltt_event_position_set(raw_data->ep, block_num, backward_num);
+		ltt_tracefile_seek_position(tf, raw_data->ep);
 		ev = ltt_tracefile_read(tf);
 		start = ltt_event_time(ev);
-		maxNum = G_MAXULONG;
+		maxNum = RESERVE_SMALL_SIZE_CUBE;
 	      }else{
 		if(block_num > 1){
-		  ltt_event_position_set(&raw_data->ep, block_num-1, 1);
-		  ltt_tracefile_seek_position(tf, &raw_data->ep);
+		  ltt_event_position_set(raw_data->ep, block_num-1, 1);
+		  ltt_tracefile_seek_position(tf, raw_data->ep);
 		  ev = ltt_tracefile_read(tf);
 		  start = ltt_event_time(ev);	    	      
 		}else{
 		  start.tv_sec  = 0;
 		  start.tv_nsec = 0;		
 		}
-		maxNum = G_MAXULONG;
+		maxNum = RESERVE_SMALL_SIZE_CUBE;
 	      }
 	    }else{
 	      if(block_num > count){
-		ltt_event_position_set(&raw_data->ep, block_num-count, 1);
-		ltt_tracefile_seek_position(tf, &raw_data->ep);
+		ltt_event_position_set(raw_data->ep, block_num-count, 1);
+		ltt_tracefile_seek_position(tf, raw_data->ep);
 		ev = ltt_tracefile_read(tf);
 		start = ltt_event_time(ev);	    	      
 	      }else{
 		start.tv_sec  = 0;
 		start.tv_nsec = 0;		
 	      }	      
-	      maxNum = G_MAXULONG;
+	      maxNum = RESERVE_SMALL_SIZE_CUBE;
 	    }
 
 	    event_viewer_data->current_event_index = event_viewer_data->start_event_index;
@@ -876,31 +956,47 @@ void get_test_data(double time_value, guint list_height,
 	if(event_viewer_data->end_event_index == event_viewer_data->number_of_events - 1){
 	  event_viewer_data->append = TRUE;
 	  first = event_viewer_data->raw_trace_data_queue->head;
+	  if(!first)break;
 	  raw_data = (RawTraceData*)g_list_nth_data(first,event_viewer_data->number_of_events - 1);
 	  start = raw_data->time;
 	  start.tv_nsec++;
 	  end.tv_sec = G_MAXULONG;
 	  end.tv_nsec = G_MAXULONG;
 	  get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE, &size);
-	}else size = 1;
-	if(size > 0) event_number = event_viewer_data->start_event_index + 1;	
-	else         event_number = event_viewer_data->start_event_index;
+	  if(size == 0){
+	    get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE_SQUARE,&size);
+	    if(size == 0)
+	      get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE_CUBE,&size);
+	  }
+	  if(size==0) event_number = event_viewer_data->start_event_index;	
+	  else event_number = event_viewer_data->number_of_events - size - list_height + 1;
+	}else event_number = event_viewer_data->start_event_index + 1;
 	break;
       case SCROLL_PAGE_DOWN:
-	if(event_viewer_data->end_event_index >= event_viewer_data->number_of_events - 1 - list_height){
+	i = event_viewer_data->number_of_events - 1 - list_height;
+	if((gint)(event_viewer_data->end_event_index) >= i){
+	  int remain_events = event_viewer_data->number_of_events - 1 
+	                      -  event_viewer_data->end_event_index;
 	  event_viewer_data->append = TRUE;
 	  first = event_viewer_data->raw_trace_data_queue->head;
+	  if(!first)break;
 	  raw_data = (RawTraceData*)g_list_nth_data(first,event_viewer_data->number_of_events - 1);
 	  start = raw_data->time;
 	  start.tv_nsec++;
 	  end.tv_sec = G_MAXULONG;
 	  end.tv_nsec = G_MAXULONG;
 	  get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE,&size);
-	}
-	if(list_height <= event_viewer_data->number_of_events - 1 - event_viewer_data->end_event_index)
-	  event_number = event_viewer_data->start_event_index + list_height - 1;	
-	else
-	  event_number = event_viewer_data->number_of_events - 1 - list_height;		  
+	  if(size == 0){
+	    get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE_SQUARE,&size);
+	    if(size == 0)
+	      get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE_CUBE,&size);
+	  }
+	  remain_events += size;
+	  if(list_height <= remain_events)
+	    event_number = event_viewer_data->number_of_events - remain_events - 1;	
+	  else
+	    event_number = event_viewer_data->number_of_events - 1 - list_height;		  
+	}else event_number = event_viewer_data->start_event_index + list_height - 1;
 	break;
       case SCROLL_JUMP:
 	event_viewer_data->append = TRUE;
@@ -911,27 +1007,33 @@ void get_test_data(double time_value, guint list_height,
 	start = ltt_time_add(event_viewer_data->time_span.startTime, time);
 	event_viewer_data->previous_value = time_value;
 	get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE,&size);
-	if(size < list_height){
+	if(size < list_height && size > 0){
 	  event_viewer_data->append = FALSE;
 	  first = event_viewer_data->raw_trace_data_queue->head;
+	  if(!first)break;
 	  raw_data = (RawTraceData*)g_list_nth_data(first,0);
 	  end = raw_data->time;
 	  end.tv_nsec--;
-	  ltt_event_position_get(&raw_data->ep, &block_num, &event_num, &tf);
+	  ltt_event_position_get(raw_data->ep, &block_num, &event_num, &tf);
 	  
 	  if(event_num > list_height - size){
 	    backward_num = event_num > RESERVE_SMALL_SIZE 
 	      ? event_num - RESERVE_SMALL_SIZE : 1;
-	    ltt_event_position_set(&raw_data->ep, block_num, backward_num);
-	    ltt_tracefile_seek_position(tf, &raw_data->ep);
+	    ltt_event_position_set(raw_data->ep, block_num, backward_num);
+	    ltt_tracefile_seek_position(tf, raw_data->ep);
 	    ev = ltt_tracefile_read(tf);
 	    start = ltt_event_time(ev);
-	    maxNum = G_MAXULONG;
+	    maxNum = RESERVE_SMALL_SIZE_CUBE;
 	    event_viewer_data->current_event_index = 0;
 	    get_events(event_viewer_data, start, end, maxNum, &size);
 	    event_viewer_data->start_event_index = event_viewer_data->current_event_index;
 	  }
 	  event_number = event_viewer_data->raw_trace_data_queue->length - list_height;
+	}else if(size == 0){
+	  get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE_SQUARE,&size);
+	  if(size == 0)
+	    get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE_CUBE,&size);
+	  event_number = 0;
 	}else{
 	  event_number = 0;
 	}
@@ -943,55 +1045,38 @@ void get_test_data(double time_value, guint list_height,
 	  break;
     }
 
+    if(event_number < 0) event_number = 0;
+
     //update the value of the scroll bar
     if(direction != SCROLL_NONE && direction != SCROLL_JUMP){
       first = event_viewer_data->raw_trace_data_queue->head;
-      raw_data = (RawTraceData*)g_list_nth_data(first,event_number);
-      time = ltt_time_sub(raw_data->time, event_viewer_data->time_span.startTime);
-      event_viewer_data->vadjust_c->value = ltt_time_to_double(time) * NANOSECONDS_PER_SECOND;
-      g_signal_stop_emission_by_name(G_OBJECT(event_viewer_data->vadjust_c), "value-changed");
-      event_viewer_data->previous_value = event_viewer_data->vadjust_c->value;
+      if(first){
+	raw_data = (RawTraceData*)g_list_nth_data(first,event_number);
+	if(!raw_data) raw_data = (RawTraceData*)g_list_nth_data(first,0);       
+	time = ltt_time_sub(raw_data->time, event_viewer_data->time_span.startTime);
+	event_viewer_data->vadjust_c->value = ltt_time_to_double(time) * NANOSECONDS_PER_SECOND;
+	g_signal_stop_emission_by_name(G_OBJECT(event_viewer_data->vadjust_c), "value-changed");
+	event_viewer_data->previous_value = event_viewer_data->vadjust_c->value;
+      }
     }
     
 
     event_viewer_data->start_event_index = event_number;
     event_viewer_data->end_event_index = event_number + list_height - 1;    
+    if(event_viewer_data->end_event_index > event_viewer_data->number_of_events - 1){
+      event_viewer_data->end_event_index = event_viewer_data->number_of_events - 1;
+    }
 
     first = event_viewer_data->raw_trace_data_queue->head;
     gtk_list_store_clear(event_viewer_data->store_m);
-    for(i=event_number; i<event_number+list_height; i++)
-      {
-	guint64 real_data;
-
-	if(i>=event_viewer_data->number_of_events) break;
-       
-	raw_data = (RawTraceData*)g_list_nth_data(first, i);
-
-	// Add a new row to the model 
-	real_data = raw_data->time.tv_sec;
-	real_data *= NANOSECONDS_PER_SECOND;
-	real_data += raw_data->time.tv_nsec;
-	gtk_list_store_append (event_viewer_data->store_m, &iter);
-	gtk_list_store_set (event_viewer_data->store_m, &iter,
-			    CPUID_COLUMN, raw_data->cpu_id,
-			    EVENT_COLUMN, raw_data->event_name,
-			    TIME_COLUMN, real_data,
-			    PID_COLUMN, raw_data->pid,
-			    ENTRY_LEN_COLUMN, raw_data->entry_length,
-			    EVENT_DESCR_COLUMN, raw_data->event_description,
-			    -1);
-/*
-	gtk_list_store_append (event_viewer_data->store_m, &iter);
-	gtk_list_store_set (event_viewer_data->store_m, &iter,
-			    CPUID_COLUMN, 0,
-			    EVENT_COLUMN, "event irq",
-			    TIME_COLUMN, i,
-			    PID_COLUMN, 100,
-			    ENTRY_LEN_COLUMN, 17,
-			    EVENT_DESCR_COLUMN, "Detailed information",
-			    -1);
-*/
-      }
+    if(!first){
+      //      event_viewer_data->previous_value = 0;
+      //      event_viewer_data->vadjust_c->value = 0.0;
+      //      gtk_widget_hide(event_viewer_data->vscroll_vc);
+      goto LAST;
+    }else gtk_widget_show(event_viewer_data->vscroll_vc);
+
+    insert_data_into_model(event_viewer_data,event_number, event_number+list_height);
   }
 #ifdef DEBUG //do not use this, it's slower and broken
   //	} else {
@@ -1054,7 +1139,9 @@ void get_test_data(double time_value, guint list_height,
   event_viewer_data->first_event = event_viewer_data->start_event_index ;
   event_viewer_data->last_event = event_viewer_data->end_event_index ;
 
-
+ LAST:
+  if(widget)
+     gdk_window_set_cursor(win, NULL);  
 
 }
 	
@@ -1093,6 +1180,8 @@ gui_events_free(EventViewerData *event_viewer_data)
 
     unreg_update_time_window(update_time_window,event_viewer_data, event_viewer_data->mw);
     unreg_update_current_time(update_current_time,event_viewer_data, event_viewer_data->mw);
+    unreg_show_viewer(show_event_detail,event_viewer_data, event_viewer_data->mw);
+    unreg_update_traceset(traceset_changed,event_viewer_data, event_viewer_data->mw);
 
     g_event_viewer_data_list = g_slist_remove(g_event_viewer_data_list, event_viewer_data);
     g_free(event_viewer_data);
@@ -1107,6 +1196,7 @@ gui_events_destructor(EventViewerData *event_viewer_data)
   /* May already been done by GTK window closing */
   if(GTK_IS_WIDGET(event_viewer_data->hbox_v)){
     gtk_widget_destroy(event_viewer_data->hbox_v);
+    g_free(event_viewer_data->filter_key);
     event_viewer_data = NULL;
   }
   
@@ -1151,11 +1241,167 @@ int event_selected_hook(void *hook_data, void *call_data)
 
 }
 
+/* If every module uses the filter, maybe these two 
+ * (add/remove_context_hooks functions) should be put in common place
+ */
+void add_context_hooks(EventViewerData * event_viewer_data, 
+		       LttvTracesetContext * tsc)
+{
+  gint i, j, k, m,n, nbi, id;
+  gint nb_tracefile, nb_control, nb_per_cpu, nb_facility, nb_event;
+  LttTrace *trace;
+  LttvTraceContext *tc;
+  LttvTracefileContext *tfc;
+  LttvTracesetSelector  * ts_s;
+  LttvTraceSelector     * t_s;
+  LttvTracefileSelector * tf_s;
+  gboolean selected;
+  LttFacility           * fac;
+  LttEventType          * et;
+  LttvEventtypeSelector * eventtype;
+
+  ts_s = (LttvTracesetSelector*)g_object_get_data(G_OBJECT(event_viewer_data->hbox_v), 
+						  event_viewer_data->filter_key);
+
+  //if there are hooks for traceset, add them here
+  
+  nbi = lttv_traceset_number(tsc->ts);
+  for(i = 0 ; i < nbi ; i++) {
+    t_s = lttv_traceset_selector_trace_get(ts_s,i);
+    selected = lttv_trace_selector_get_selected(t_s);
+    if(!selected) continue;
+    tc = tsc->traces[i];
+    trace = tc->t;
+    //if there are hooks for trace, add them here
+
+    nb_control = ltt_trace_control_tracefile_number(trace);
+    nb_per_cpu = ltt_trace_per_cpu_tracefile_number(trace);
+    nb_tracefile = nb_control + nb_per_cpu;
+    
+    for(j = 0 ; j < nb_tracefile ; j++) {
+      tf_s = lttv_trace_selector_tracefile_get(t_s,j);
+      selected = lttv_tracefile_selector_get_selected(tf_s);
+      if(!selected) continue;
+      
+      if(j < nb_control)
+	tfc = tc->control_tracefiles[j];
+      else
+	tfc = tc->per_cpu_tracefiles[j - nb_control];
+      
+      //if there are hooks for tracefile, add them here
+      //      lttv_tracefile_context_add_hooks(tfc, NULL,NULL,NULL,NULL,
+      //				       event_viewer_data->before_event_hooks,NULL);
+
+      nb_facility = ltt_trace_facility_number(trace);
+      n = 0;
+      for(k=0;k<nb_facility;k++){
+	fac = ltt_trace_facility_get(trace,k);
+	nb_event = (int) ltt_facility_eventtype_number(fac);
+	for(m=0;m<nb_event;m++){
+	  et = ltt_facility_eventtype_get(fac,m);
+	  eventtype = lttv_tracefile_selector_eventtype_get(tf_s, n);
+	  selected = lttv_eventtype_selector_get_selected(eventtype);
+	  if(selected){
+	    id = (gint) ltt_eventtype_id(et);
+	    lttv_tracefile_context_add_hooks_by_id(tfc,id, 
+						   event_viewer_data->before_event_hooks,
+						   NULL);
+	  }
+	  n++;
+	}
+      }
+
+    }
+  }
+  
+  //add hooks for process_traceset
+  //    context_add_hooks_api(event_viewer_data->mw, NULL, NULL, NULL, NULL, NULL, NULL,
+  //			  NULL, NULL, NULL,event_viewer_data->before_event_hooks,NULL);  
+}
+
+
+void remove_context_hooks(EventViewerData * event_viewer_data, 
+			  LttvTracesetContext * tsc)
+{
+  gint i, j, k, m, nbi, n, id;
+  gint nb_tracefile, nb_control, nb_per_cpu, nb_facility, nb_event;
+  LttTrace *trace;
+  LttvTraceContext *tc;
+  LttvTracefileContext *tfc;
+  LttvTracesetSelector  * ts_s;
+  LttvTraceSelector     * t_s;
+  LttvTracefileSelector * tf_s;
+  gboolean selected;
+  LttFacility           * fac;
+  LttEventType          * et;
+  LttvEventtypeSelector * eventtype;
+
+  ts_s = (LttvTracesetSelector*)g_object_get_data(G_OBJECT(event_viewer_data->hbox_v), 
+						  event_viewer_data->filter_key);
+
+  //if there are hooks for traceset, remove them here
+  
+  nbi = lttv_traceset_number(tsc->ts);
+  for(i = 0 ; i < nbi ; i++) {
+    t_s = lttv_traceset_selector_trace_get(ts_s,i);
+    selected = lttv_trace_selector_get_selected(t_s);
+    if(!selected) continue;
+    tc = tsc->traces[i];
+    trace = tc->t;
+    //if there are hooks for trace, remove them here
+
+    nb_control = ltt_trace_control_tracefile_number(trace);
+    nb_per_cpu = ltt_trace_per_cpu_tracefile_number(trace);
+    nb_tracefile = nb_control + nb_per_cpu;
+    
+    for(j = 0 ; j < nb_tracefile ; j++) {
+      tf_s = lttv_trace_selector_tracefile_get(t_s,j);
+      selected = lttv_tracefile_selector_get_selected(tf_s);
+      if(!selected) continue;
+      
+      if(j < nb_control)
+	tfc = tc->control_tracefiles[j];
+      else
+	tfc = tc->per_cpu_tracefiles[j - nb_control];
+      
+      //if there are hooks for tracefile, remove them here
+      //      lttv_tracefile_context_remove_hooks(tfc, NULL,NULL,NULL,NULL,
+      //					  event_viewer_data->before_event_hooks,NULL);
+
+      nb_facility = ltt_trace_facility_number(trace);
+      n = 0;
+      for(k=0;k<nb_facility;k++){
+	fac = ltt_trace_facility_get(trace,k);
+	nb_event = (int) ltt_facility_eventtype_number(fac);
+	for(m=0;m<nb_event;m++){
+	  et = ltt_facility_eventtype_get(fac,m);
+	  eventtype = lttv_tracefile_selector_eventtype_get(tf_s, n);
+	  selected = lttv_eventtype_selector_get_selected(eventtype);
+	  if(selected){
+	    id = (gint) ltt_eventtype_id(et);
+	    lttv_tracefile_context_remove_hooks_by_id(tfc,id); 
+	  }
+	  n++;
+	}
+      }
+    }
+  }
+  //remove hooks from context
+  //    context_remove_hooks_api(event_viewer_data->mw, NULL, NULL, NULL, NULL, NULL, NULL,
+  //			     NULL, NULL, NULL,event_viewer_data->before_event_hooks,NULL);
+}
+
 
 gboolean update_time_window(void * hook_data, void * call_data)
 {
   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
-  event_viewer_data->time_window = *(TimeWindow*)call_data;
+  LttvTracesetContext * tsc = get_traceset_context(event_viewer_data->mw);
+
+  if(event_viewer_data->shown == FALSE){
+    event_viewer_data->time_window = *(TimeWindow*)call_data;
+    
+    add_context_hooks(event_viewer_data, tsc);
+  }
 
   return FALSE;
 }
@@ -1168,16 +1414,23 @@ gboolean update_current_time(void * hook_data, void * call_data)
                   + event_viewer_data->current_time.tv_nsec;
   GtkTreeIter iter;
   guint64 time;
-  int count = 0;
+  int count = -1;
   GtkTreeModel* model = (GtkTreeModel*)event_viewer_data->store_m;
+  GList * list;
+  RawTraceData * data, *data1;
+  GtkTreePath* path;
+  char str_path[64];
+  int i, j;
+  LttTime t;
 
-
+  //check if the event is shown in the current viewer
   if(gtk_tree_model_get_iter_first(model, &iter)){
     while(1){
       gtk_tree_model_get(model, &iter, TIME_COLUMN, &time, -1);
       if(time < nsec){
 	if(!gtk_tree_model_iter_next(model, &iter)){
-	  return TRUE;
+	  count = -1;
+	  break;
 	}
 	count++;
       }else{
@@ -1187,31 +1440,88 @@ gboolean update_current_time(void * hook_data, void * call_data)
     //    event_selected_hook(event_viewer_data, &count);
   }
 
+  //the event is not shown in the current viewer
+  if(count == -1){
+    count = 0;
+    //check if the event is in the buffer
+    list = event_viewer_data->raw_trace_data_queue->head;
+    data = (RawTraceData*)g_list_nth_data(list,0);
+    data1 = (RawTraceData*)g_list_nth_data(list,event_viewer_data->raw_trace_data_queue->length-1);
+
+    //the event is in the buffer
+    if(ltt_time_compare(data->time, event_viewer_data->current_time)<=0 &&
+       ltt_time_compare(data1->time, event_viewer_data->current_time)>=0){
+      for(i=0;i<event_viewer_data->raw_trace_data_queue->length;i++){
+	data = (RawTraceData*)g_list_nth_data(list,i);
+	if(ltt_time_compare(data->time, event_viewer_data->current_time) < 0){
+	  count++;
+	  continue;
+	}
+	break;
+      }
+      if(event_viewer_data->raw_trace_data_queue->length-count < event_viewer_data->num_visible_events){
+	j = event_viewer_data->raw_trace_data_queue->length - event_viewer_data->num_visible_events;
+	count -= j;
+	data = (RawTraceData*)g_list_nth_data(list,j);
+      }else{
+	j = count;
+	count = 0;
+      }
+      t = ltt_time_sub(data->time, event_viewer_data->time_span.startTime);
+      event_viewer_data->vadjust_c->value = ltt_time_to_double(t) * NANOSECONDS_PER_SECOND;
+      g_signal_stop_emission_by_name(G_OBJECT(event_viewer_data->vadjust_c), "value-changed");
+      event_viewer_data->previous_value = event_viewer_data->vadjust_c->value;
+      insert_data_into_model(event_viewer_data,j, j+event_viewer_data->num_visible_events);      
+    }else{//the event is not in the buffer
+      LttTime start = ltt_time_sub(event_viewer_data->current_time, event_viewer_data->time_span.startTime);
+      double position = ltt_time_to_double(start) * NANOSECONDS_PER_SECOND;
+      gtk_adjustment_set_value(event_viewer_data->vadjust_c, position);
+    }
+  }
+
+  sprintf(str_path,"%d\0",count);
+  path = gtk_tree_path_new_from_string (str_path);
+  gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
+  gtk_tree_path_free(path);  
+
+  return FALSE;
+}
+
+gboolean traceset_changed(void * hook_data, void * call_data)
+{
+  EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
+  LttTime start;
+  
+  remove_all_items_from_queue(event_viewer_data->raw_trace_data_queue);
+  gtk_list_store_clear(event_viewer_data->store_m);
+  event_viewer_data->shown = FALSE;
+  event_viewer_data->append = TRUE;
+
+  get_traceset_time_span(event_viewer_data->mw, &event_viewer_data->time_span);
+  start = ltt_time_sub(event_viewer_data->time_span.endTime, event_viewer_data->time_span.startTime);
+  event_viewer_data->vadjust_c->upper = ltt_time_to_double(start) * NANOSECONDS_PER_SECOND;
+  //  event_viewer_data->vadjust_c->value = 0;
+
   return FALSE;
 }
 
+
 void tree_v_grab_focus(GtkWidget *widget, gpointer data){
   EventViewerData *event_viewer_data = (EventViewerData *)data;
   MainWindow * mw = event_viewer_data->mw;
   set_focused_pane(mw, gtk_widget_get_parent(event_viewer_data->hbox_v));
 }
 
-void get_events(EventViewerData* event_viewer_data, LttTime start, 
-		LttTime end,unsigned max_num_events, unsigned * real_num_events)
+void update_raw_data_array(EventViewerData* event_viewer_data, unsigned size)
 {
-  int size;
   RawTraceData * data;
-  context_add_hooks_api(event_viewer_data->mw, NULL, NULL, NULL, NULL, NULL, NULL,
-			NULL, NULL, NULL,event_viewer_data->before_event_hooks,NULL);
-  process_traceset_api(event_viewer_data->mw, start, end, max_num_events);
-  context_remove_hooks_api(event_viewer_data->mw, NULL, NULL, NULL, NULL, NULL, NULL,
-			   NULL, NULL, NULL,event_viewer_data->before_event_hooks,NULL);
-
-  size = event_viewer_data->raw_trace_data_queue_tmp->length;
-  *real_num_events = size;
   if(size > 0){
-    int pid, tmpPid, i;
+    int pid, tmpPid, i,j,len;
     GList * list, *tmpList;
+    GArray * pid_array, * tmp_pid_array;
+    
+    pid_array     = g_array_sized_new(FALSE, TRUE, sizeof(int), 10);
+    tmp_pid_array = g_array_sized_new(FALSE, TRUE, sizeof(int), 10);
 
     //if the queue is full, remove some data, keep the size of the queue constant
     while(event_viewer_data->raw_trace_data_queue->length + size > RESERVE_BIG_SIZE){
@@ -1224,30 +1534,95 @@ void get_events(EventViewerData* event_viewer_data, LttTime start,
       list    = event_viewer_data->raw_trace_data_queue->head;
       tmpList = event_viewer_data->raw_trace_data_queue_tmp->head;
       if(event_viewer_data->append){
-	data = (RawTraceData*)g_list_nth_data(list, event_viewer_data->raw_trace_data_queue->length-1);
-	pid  = data->pid;
-	data = (RawTraceData*)g_list_nth_data(tmpList, 0);
-	tmpPid = data->pid;
+	for(i= event_viewer_data->raw_trace_data_queue->length-1;i>=0;i--){
+	  data = (RawTraceData*)g_list_nth_data(list,i);
+	  len = data->pid==0 ? -2 : data->pid;
+	  if(data->cpu_id+1 > pid_array->len){
+	    pid_array = g_array_set_size(pid_array,data->cpu_id+1);	    
+	    pid_array = g_array_insert_val(pid_array,data->cpu_id,len);
+	    pid_array = g_array_remove_index(pid_array,data->cpu_id+1);
+	  }else if(data->cpu_id+1 < pid_array->len){
+	    pid = g_array_index(pid_array,int,data->cpu_id);
+	    if(pid == 0){
+	      pid_array = g_array_insert_val(pid_array,data->cpu_id,len);
+	      pid_array = g_array_remove_index(pid_array,data->cpu_id+1);
+	    }
+	  }	  
+	}
+
+	for(i=0;i<event_viewer_data->raw_trace_data_queue_tmp->length;i++){
+	  data = (RawTraceData*)g_list_nth_data(tmpList,i);
+	  len = data->pid==0 ? -2 : data->pid;
+	  if(data->cpu_id+1 > tmp_pid_array->len){
+	    tmp_pid_array = g_array_set_size(tmp_pid_array,data->cpu_id+1);	    
+	    tmp_pid_array = g_array_insert_val(tmp_pid_array,data->cpu_id,len);
+	    tmp_pid_array = g_array_remove_index(tmp_pid_array,data->cpu_id+1);
+	  }else if(data->cpu_id+1 < tmp_pid_array->len){
+	    pid = g_array_index(tmp_pid_array,int,data->cpu_id);
+	    if(pid == 0){
+	      tmp_pid_array = g_array_insert_val(tmp_pid_array,data->cpu_id,len);
+	      tmp_pid_array = g_array_remove_index(tmp_pid_array,data->cpu_id+1);
+	    }
+	  }	  
+	}
       }else{
-	data = (RawTraceData*)g_list_nth_data(list, 0);
-	pid  = data->pid;
-	data = (RawTraceData*)g_list_nth_data(tmpList, event_viewer_data->raw_trace_data_queue_tmp->length-1);
-	tmpPid = data->pid;
-      }
-      
-      if(pid == -1 && tmpPid != -1){
 	for(i=0;i<event_viewer_data->raw_trace_data_queue->length;i++){
 	  data = (RawTraceData*)g_list_nth_data(list,i);
-	  if(data->pid == -1) data->pid = tmpPid;
+	  len = data->pid==0 ? -2 : data->pid;
+	  if(data->cpu_id+1 > pid_array->len){
+	    pid_array = g_array_set_size(pid_array,data->cpu_id+1);	    
+	    pid_array = g_array_insert_val(pid_array,data->cpu_id,len);
+	    pid_array = g_array_remove_index(pid_array,data->cpu_id+1);
+	  }else if(data->cpu_id+1 < pid_array->len){
+	    pid = g_array_index(pid_array,int,data->cpu_id);
+	    if(pid == 0){
+	      pid_array = g_array_insert_val(pid_array,data->cpu_id,len);
+	      pid_array = g_array_remove_index(pid_array,data->cpu_id+1);
+	    }
+	  }	  
 	}
-      }else if(pid != -1 && tmpPid == -1){
-	for(i=0;i<event_viewer_data->raw_trace_data_queue_tmp->length;i++){
+
+	for(i=event_viewer_data->raw_trace_data_queue_tmp->length-1;i>=0;i--){
 	  data = (RawTraceData*)g_list_nth_data(tmpList,i);
-	  if(data->pid == -1) data->pid = pid;
+	  len = data->pid==0 ? -2 : data->pid;
+	  if(data->cpu_id+1 > tmp_pid_array->len){
+	    tmp_pid_array = g_array_set_size(tmp_pid_array,data->cpu_id+1);	    
+	    tmp_pid_array = g_array_insert_val(tmp_pid_array,data->cpu_id,len);
+	    tmp_pid_array = g_array_remove_index(tmp_pid_array,data->cpu_id+1);
+	  }else if(data->cpu_id+1 < tmp_pid_array->len){
+	    pid = g_array_index(tmp_pid_array,int,data->cpu_id);
+	    if(pid == 0){
+	      tmp_pid_array = g_array_insert_val(tmp_pid_array,data->cpu_id,len);
+	      tmp_pid_array = g_array_remove_index(tmp_pid_array,data->cpu_id+1);
+	    }
+	  }	  
+	}
+      }
+      
+      len = pid_array->len > tmp_pid_array->len ? tmp_pid_array->len : pid_array->len;
+      for(j=0;j<len;j++){
+	pid = g_array_index(pid_array,int, j);
+	tmpPid = g_array_index(tmp_pid_array,int,j);
+	if(pid == -2)pid = 0;
+	if(tmpPid == -2) tmpPid = 0;
+	
+	if(pid == -1 && tmpPid != -1){
+	  for(i=0;i<event_viewer_data->raw_trace_data_queue->length;i++){
+	    data = (RawTraceData*)g_list_nth_data(list,i);
+	    if(data->pid == -1 && data->cpu_id == j) data->pid = tmpPid;
+	  }
+	}else if(pid != -1 && tmpPid == -1){
+	  for(i=0;i<event_viewer_data->raw_trace_data_queue_tmp->length;i++){
+	    data = (RawTraceData*)g_list_nth_data(tmpList,i);
+	    if(data->pid == -1 && data->cpu_id == j) data->pid = pid;
+	  }
 	}
       }
     }
 
+    g_array_free(pid_array,TRUE);
+    g_array_free(tmp_pid_array, TRUE);
+
     //add data from tmp queue into the queue
     event_viewer_data->number_of_events = event_viewer_data->raw_trace_data_queue->length 
                                         + event_viewer_data->raw_trace_data_queue_tmp->length;
@@ -1267,6 +1642,28 @@ void get_events(EventViewerData* event_viewer_data, LttTime start,
   }
 }
 
+void get_events(EventViewerData* event_viewer_data, LttTime start, 
+		LttTime end,unsigned max_num_events, unsigned * real_num_events)
+{
+  int size;
+  LttvTracesetContext * tsc = get_traceset_context(event_viewer_data->mw);
+
+  //  context_add_hooks_api(event_viewer_data->mw, NULL, NULL, NULL, NULL, NULL, NULL,
+  //			NULL, NULL, NULL,event_viewer_data->before_event_hooks,NULL);
+  add_context_hooks(event_viewer_data,tsc);
+
+  process_traceset_api(event_viewer_data->mw, start, end, max_num_events);
+
+  remove_context_hooks(event_viewer_data,tsc);
+  //  context_remove_hooks_api(event_viewer_data->mw, NULL, NULL, NULL, NULL, NULL, NULL,
+  //			   NULL, NULL, NULL,event_viewer_data->before_event_hooks,NULL);
+
+  size = event_viewer_data->raw_trace_data_queue_tmp->length;
+  *real_num_events = size;
+  
+  update_raw_data_array(event_viewer_data,size);
+}
+
 static void get_event_detail(LttEvent *e, LttField *f, GString * s)
 {
   LttType *type;
@@ -1363,20 +1760,27 @@ gboolean parse_event(void *hook_data, void *call_data)
   field = ltt_event_field(e);
   time = ltt_event_time(e);
 
-  if(event_viewer_data->raw_trace_data_queue_tmp->length){ 
-    list = g_list_last(event_viewer_data->raw_trace_data_queue_tmp->head);
-    prev_raw_trace_data = (RawTraceData *)(list->data);
-  }
-
   tmp_raw_trace_data = g_new(RawTraceData,1);
   tmp_raw_trace_data->cpu_id = ltt_event_cpu_id(e);
   tmp_raw_trace_data->event_name = g_strdup(ltt_eventtype_name(ltt_event_eventtype(e)));
   tmp_raw_trace_data->time = time;
+  tmp_raw_trace_data->ep = ltt_event_position_new();
+
+  if(event_viewer_data->raw_trace_data_queue_tmp->length){ 
+    list = event_viewer_data->raw_trace_data_queue_tmp->head;
+    for(i=event_viewer_data->raw_trace_data_queue_tmp->length-1;i>=0;i--){
+      data = (RawTraceData *)g_list_nth_data(list,i);
+      if(data->cpu_id == tmp_raw_trace_data->cpu_id){
+	prev_raw_trace_data = data;
+	break;
+      }
+    }    
+  }  
 
   if(prev_raw_trace_data) tmp_raw_trace_data->pid = prev_raw_trace_data->pid;
   else tmp_raw_trace_data->pid = -1;
 
-  tmp_raw_trace_data->entry_length = field == NULL ? 0 : field->field_size;
+  tmp_raw_trace_data->entry_length = field == NULL ? 0 : ltt_field_size(field);
   if(field) get_event_detail(e, field, detail_event);
   tmp_raw_trace_data->event_description  = g_strdup(detail_event->str);
 
@@ -1391,12 +1795,14 @@ gboolean parse_event(void *hook_data, void *call_data)
       list = event_viewer_data->raw_trace_data_queue_tmp->head;
       for(i=0;i<event_viewer_data->raw_trace_data_queue_tmp->length;i++){
  	data = (RawTraceData *)g_list_nth_data(list,i);
-	data->pid = out;
+	if(data->cpu_id == tmp_raw_trace_data->cpu_id){
+	  data->pid = out;
+	}
       }
     }
   }
   
-  ltt_event_position(e, &tmp_raw_trace_data->ep);
+  ltt_event_position(e, tmp_raw_trace_data->ep);
 
   if(event_viewer_data->raw_trace_data_queue_tmp->length >= RESERVE_SMALL_SIZE){
     if(event_viewer_data->append){