X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Fmodules%2Fgui%2Flttvwindow%2Flttvwindow%2Flttvwindowtraces.c;h=c5bd1935e48382ef43e126e71d1a20690f20f776;hb=147c6f7fc4f80e38b970052de8bcab28f4f45acc;hp=c1df4513c5816753138439679b7f1f08dcbe390c;hpb=93ac601b7487eba4b0733f44117f45fa9dd0baee;p=lttv.git

diff --git a/ltt/branches/poly/lttv/modules/gui/lttvwindow/lttvwindow/lttvwindowtraces.c b/ltt/branches/poly/lttv/modules/gui/lttvwindow/lttvwindow/lttvwindowtraces.c
index c1df4513..c5bd1935 100644
--- a/ltt/branches/poly/lttv/modules/gui/lttvwindow/lttvwindow/lttvwindowtraces.c
+++ b/ltt/branches/poly/lttv/modules/gui/lttvwindow/lttvwindow/lttvwindowtraces.c
@@ -38,7 +38,9 @@
 #include <lttv/tracecontext.h>
 #include <lttvwindow/lttvwindowtraces.h>
 #include <lttvwindow/lttvwindow.h> // for CHUNK_NUM_EVENTS
+#include <lttvwindow/mainwindow-private.h> /* for main window structure */
 
+extern GSList * g_main_window_list;
 
 typedef struct _BackgroundRequest {
   LttvAttributeName module_name; /* Hook path in global attributes,
@@ -46,6 +48,7 @@ typedef struct _BackgroundRequest {
                                     i.e. modulename */
   LttvTrace *trace; /* trace concerned */
   GtkWidget *dialog;  /* Dialog linked with the request, may be NULL */
+  GtkWidget *parent_window; /* Parent window the dialog must be transient for */
 } BackgroundRequest;
 
 typedef struct _BackgroundNotify {
@@ -69,7 +72,7 @@ gboolean lttvwindowtraces_process_pending_requests(LttvTrace *trace);
  *         NULL is returned if the trace is not present
  */
 
-LttvTrace *lttvwindowtraces_get_trace_by_name(gchar *path)
+__EXPORT LttvTrace *lttvwindowtraces_get_trace_by_name(gchar *path)
 {
   guint i;
 
@@ -94,19 +97,22 @@ LttvTrace *lttvwindowtraces_get_trace_by_name(gchar *path)
 
 /* Get a trace by its number identifier */
 
-LttvTrace *lttvwindowtraces_get_trace(guint num)
+__EXPORT LttvTrace *lttvwindowtraces_get_trace(guint num)
 {
   LttvAttribute *g_attribute = lttv_global_attributes();
   LttvAttribute *attribute;
   LttvAttributeType type;
   LttvAttributeName name;
   LttvAttributeValue value;
+	gboolean is_named;
 
-  g_assert(attribute = 
+  attribute = 
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
-                                LTTV_TRACES)));
+                                LTTV_TRACES));
+  g_assert(attribute);
   
-  type = lttv_iattribute_get(LTTV_IATTRIBUTE(attribute), num, &name, &value);
+  type = lttv_iattribute_get(LTTV_IATTRIBUTE(attribute), num, &name, &value,
+			&is_named);
 
   if(type == LTTV_POINTER) {
     return (LttvTrace *)*(value.v_pointer);
@@ -117,15 +123,15 @@ LttvTrace *lttvwindowtraces_get_trace(guint num)
 
 /* Total number of traces */
 
-guint lttvwindowtraces_get_number()
+__EXPORT guint lttvwindowtraces_get_number()
 {
   LttvAttribute *g_attribute = lttv_global_attributes();
   LttvAttribute *attribute;
-  LttvAttributeValue value;
 
-  g_assert(attribute = 
+  attribute = 
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
-                                LTTV_TRACES)));
+                                LTTV_TRACES));
+  g_assert(attribute);
  
   return ( lttv_iattribute_get_number(LTTV_IATTRIBUTE(attribute)) );
 }
@@ -137,21 +143,23 @@ void lttvwindowtraces_add_trace(LttvTrace *trace)
   LttvAttribute *g_attribute = lttv_global_attributes();
   LttvAttribute *attribute;
   LttvAttributeValue value;
-  guint num;
   struct stat buf;
   gchar attribute_path[PATH_MAX];
+  int result;
+  gboolean result_b;
 
   if(stat(g_quark_to_string(ltt_trace_name(lttv_trace(trace))), &buf)) {
     g_warning("lttvwindowtraces_add_trace: Trace %s not found",
         g_quark_to_string(ltt_trace_name(lttv_trace(trace))));
     return;
   }
-  g_assert(
-      snprintf(attribute_path, PATH_MAX, "%llu:%llu", buf.st_dev, buf.st_ino) >= 0);
+  result = snprintf(attribute_path, PATH_MAX, "%llu:%llu", buf.st_dev, buf.st_ino);
+  g_assert(result >= 0);
   
-  g_assert(attribute = 
+  attribute = 
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
-                                LTTV_TRACES)));
+                                LTTV_TRACES));
+  g_assert(attribute);
     
   value = lttv_attribute_add(attribute,
                      g_quark_from_string(attribute_path),
@@ -165,28 +173,33 @@ void lttvwindowtraces_add_trace(LttvTrace *trace)
   //LttvTracesetContextPosition *sync_position;
   
   attribute = lttv_trace_attribute(trace);
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result_b = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_COMPUTATION_TRACESET,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result_b);
+
   ts = lttv_traceset_new();
   *(value.v_pointer) = ts;
  
   lttv_traceset_add(ts,trace);
 
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result_b = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_COMPUTATION_TRACESET_CONTEXT,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result_b);
+
   tss = g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
   *(value.v_pointer) = tss;
   
   lttv_context_init(LTTV_TRACESET_CONTEXT(tss), ts);
 #if 0
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result_b = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_COMPUTATION_SYNC_POSITION,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result_b);
 
   sync_position = lttv_traceset_context_position_new();
   *(value.v_pointer) = sync_position;
@@ -206,7 +219,6 @@ void lttvwindowtraces_add_trace(LttvTrace *trace)
   value = lttv_attribute_add(attribute,
                      LTTV_NOTIFY_CURRENT,
                      LTTV_POINTER);
- 
 }
 
 /* Remove a trace from the global attributes */
@@ -217,10 +229,12 @@ void lttvwindowtraces_remove_trace(LttvTrace *trace)
   LttvAttribute *attribute;
   LttvAttributeValue value;
   guint i;
+  gboolean result;
 
-  g_assert(attribute =
+  attribute =
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
-                                LTTV_TRACES)));
+                                LTTV_TRACES));
+  g_assert(attribute);
 
   for(i=0;i<lttvwindowtraces_get_number();i++) {
     LttvTrace *trace_v = lttvwindowtraces_get_trace(i);
@@ -254,16 +268,20 @@ void lttvwindowtraces_remove_trace(LttvTrace *trace)
       lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute),
                                      LTTV_NOTIFY_CURRENT);
 
-      g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(l_attribute),
+      result = lttv_iattribute_find(LTTV_IATTRIBUTE(l_attribute),
                                     LTTV_COMPUTATION_TRACESET,
                                     LTTV_POINTER,
-                                    &value));
+                                    &value);
+      g_assert(result);
+
       ts = (LttvTraceset*)*(value.v_pointer);
 #if 0   
-      g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(l_attribute),
+      result = lttv_iattribute_find(LTTV_IATTRIBUTE(l_attribute),
                                     LTTV_COMPUTATION_SYNC_POSITION,
                                     LTTV_POINTER,
-                                    &value));
+                                    &value);
+      g_assert(result);
+
       sync_position = (LttvTracesetContextPosition*)*(value.v_pointer);
       lttv_traceset_context_position_destroy(sync_position);
       
@@ -271,10 +289,12 @@ void lttvwindowtraces_remove_trace(LttvTrace *trace)
                                      LTTV_COMPUTATION_SYNC_POSITION);
 
 #endif //0
-      g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(l_attribute),
+      result = lttv_iattribute_find(LTTV_IATTRIBUTE(l_attribute),
                                     LTTV_COMPUTATION_TRACESET_CONTEXT,
                                     LTTV_POINTER,
-                                    &value));
+                                    &value);
+      g_assert(result);
+
       tss = (LttvTracesetStats*)*(value.v_pointer);
       
       lttv_context_fini(LTTV_TRACESET_CONTEXT(tss));
@@ -306,13 +326,14 @@ static void destroy_dialog(BackgroundRequest *bg_req)
  *
  * The memory allocated for the request will be managed by the API.
  * 
+ * @param widget the current Window
  * @param trace the trace to compute
  * @param module_name the name of the module which registered global computation
  *                    hooks.
  */
 
-void lttvwindowtraces_background_request_queue
-                     (LttvTrace *trace, gchar *module_name)
+__EXPORT void lttvwindowtraces_background_request_queue
+                     (GtkWidget *widget, LttvTrace *trace, gchar *module_name)
 {
   BackgroundRequest *bg_req;
   LttvAttribute *attribute = lttv_trace_attribute(trace);
@@ -321,19 +342,21 @@ void lttvwindowtraces_background_request_queue
   LttvAttributeValue value;
   LttvAttributeType type;
   GSList **slist;
-  guint num;
+  gboolean result;
 
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_REQUESTS_QUEUE,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
+
   slist = (GSList**)(value.v_pointer);
 
   /* Verify that the calculator is loaded */
-  g_assert(module_attribute =
+  module_attribute =
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
-                                LTTV_COMPUTATION)));
-
+                                LTTV_COMPUTATION));
+  g_assert(module_attribute);
 
   type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
                                      g_quark_from_string(module_name),
@@ -359,14 +382,21 @@ void lttvwindowtraces_background_request_queue
   g_info("Background computation for %s started for trace %p", module_name,
       trace);
   GtkWidget *dialog = 
-    gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, 
+    gtk_message_dialog_new(
+      GTK_WINDOW(widget),
+      GTK_DIALOG_DESTROY_WITH_PARENT,
+      GTK_MESSAGE_INFO, GTK_BUTTONS_OK, 
       "Background computation for %s started for trace %s", 
       module_name,
       g_quark_to_string(ltt_trace_name(lttv_trace(trace))));
+  gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(widget));
   g_signal_connect_swapped (dialog, "response",
       G_CALLBACK (destroy_dialog),
       bg_req);
   bg_req->dialog = dialog;
+  /* the parent window might vanish : only use this pointer for a 
+   * comparison with existing windows */
+  bg_req->parent_window = gtk_widget_get_toplevel(widget);
   gtk_widget_show(dialog);
 }
 
@@ -394,11 +424,14 @@ void lttvwindowtraces_background_request_remove
   LttvAttributeValue value;
   GSList *iter = NULL;
   GSList **slist;
+  gboolean result;
 
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_REQUESTS_QUEUE,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
+
   slist = (GSList**)(value.v_pointer);
 
   for(iter=*slist;iter!=NULL;) {
@@ -421,18 +454,21 @@ void lttvwindowtraces_background_request_remove
  *
  */
 
-gboolean lttvwindowtraces_background_request_find
+__EXPORT gboolean lttvwindowtraces_background_request_find
                      (LttvTrace *trace, gchar *module_name)
 {
   LttvAttribute *attribute = lttv_trace_attribute(trace);
   LttvAttributeValue value;
   GSList *iter = NULL;
   GSList **slist;
+  gboolean result;
 
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_REQUESTS_QUEUE,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
+
   slist = (GSList**)(value.v_pointer);
 
   for(iter=*slist;iter!=NULL;) {
@@ -459,7 +495,7 @@ gboolean lttvwindowtraces_background_request_find
  * @param notify  Hook to call when the notify position is passed
  */
 
-void lttvwindowtraces_background_notify_queue
+__EXPORT void lttvwindowtraces_background_notify_queue
  (gpointer                     owner,
   LttvTrace                   *trace,
   LttTime                      notify_time,
@@ -470,17 +506,22 @@ void lttvwindowtraces_background_notify_queue
   LttvAttribute *attribute = lttv_trace_attribute(trace);
   LttvAttributeValue value;
   GSList **slist;
+  gboolean result;
 
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_NOTIFY_QUEUE,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
+
   slist = (GSList**)(value.v_pointer);
  
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_COMPUTATION_TRACESET_CONTEXT,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
+
   LttvTracesetContext *tsc = (LttvTracesetContext*)(value.v_pointer);
 
   bg_notify = g_new(BackgroundNotify,1);
@@ -513,7 +554,7 @@ void lttvwindowtraces_background_notify_queue
  * @param notify  Hook to call when the notify position is passed
  */
 
-void lttvwindowtraces_background_notify_current
+__EXPORT void lttvwindowtraces_background_notify_current
  (gpointer                     owner,
   LttvTrace                   *trace,
   LttTime                      notify_time,
@@ -524,17 +565,22 @@ void lttvwindowtraces_background_notify_current
   LttvAttribute *attribute = lttv_trace_attribute(trace);
   LttvAttributeValue value;
   GSList **slist;
+  gboolean result;
 
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_NOTIFY_CURRENT,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
+
   slist = (GSList**)(value.v_pointer);
 
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_COMPUTATION_TRACESET_CONTEXT,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
+
   LttvTracesetContext *tsc = (LttvTracesetContext*)(value.v_pointer);
 
 
@@ -574,7 +620,7 @@ static void notify_request_free(BackgroundNotify *notify_req)
  * @param owner owner of the background notification
  */
 
-void lttvwindowtraces_background_notify_remove(gpointer owner)
+__EXPORT void lttvwindowtraces_background_notify_remove(gpointer owner)
 {
   guint i;
 
@@ -584,15 +630,18 @@ void lttvwindowtraces_background_notify_remove(gpointer owner)
     LttvTrace *trace_v = lttvwindowtraces_get_trace(i);
     GSList **slist;
     GSList *iter = NULL;
+    gboolean result;
     
     g_assert(trace_v != NULL);
 
     attribute = lttv_trace_attribute(trace_v);
 
-    g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+    result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                   LTTV_NOTIFY_QUEUE,
                                   LTTV_POINTER,
-                                  &value));
+                                  &value);
+    g_assert(result);
+
     slist = (GSList**)(value.v_pointer);
  
     for(iter=*slist;iter!=NULL;) {
@@ -609,10 +658,12 @@ void lttvwindowtraces_background_notify_remove(gpointer owner)
       }
     }
 
-    g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+    result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                   LTTV_NOTIFY_CURRENT,
                                   LTTV_POINTER,
-                                  &value));
+                                  &value);
+    g_assert(result);
+
     slist = (GSList**)(value.v_pointer);
  
     for(iter=*slist;iter!=NULL;) {
@@ -644,14 +695,16 @@ void lttvwindowtraces_add_computation_hooks(LttvAttributeName module_name,
   LttvAttributeValue value;
 
  
-  g_assert(module_attribute =
+  module_attribute =
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
-                                LTTV_COMPUTATION)));
+                                LTTV_COMPUTATION));
+  g_assert(module_attribute);
 
-  g_assert(module_attribute =
+  module_attribute =
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
                                 LTTV_IATTRIBUTE(module_attribute),
-                                module_name)));
+                                module_name));
+  g_assert(module_attribute);
 
   /* Call the module's hook adder */
   type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
@@ -673,14 +726,16 @@ void lttvwindowtraces_remove_computation_hooks(LttvAttributeName module_name,
   LttvAttributeType type;
   LttvAttributeValue value;
  
-  g_assert(module_attribute =
+  module_attribute =
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
-                                LTTV_COMPUTATION)));
+                                LTTV_COMPUTATION));
+  g_assert(module_attribute);
 
-  g_assert(module_attribute =
+  module_attribute =
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
                                 LTTV_IATTRIBUTE(module_attribute),
-                                module_name)));
+                                module_name));
+  g_assert(module_attribute);
 
   /* Call the module's hook remover */
   type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
@@ -705,17 +760,18 @@ void lttvwindowtraces_call_before_chunk(LttvAttributeName module_name,
   LttvHooks *before_chunk_tracefile=NULL;
   LttvHooks *event_hook=NULL;
   LttvHooksById *event_hook_by_id=NULL;
-  LttvTracesetStats *tss = LTTV_TRACESET_STATS(tsc);
 
  
-  g_assert(module_attribute =
+  module_attribute =
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
-                                LTTV_COMPUTATION)));
+                                LTTV_COMPUTATION));
+  g_assert(module_attribute);
 
-  g_assert(module_attribute =
+  module_attribute =
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
                                 LTTV_IATTRIBUTE(module_attribute),
-                                module_name)));
+                                module_name));
+  g_assert(module_attribute);
 
   type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
                                      LTTV_BEFORE_CHUNK_TRACESET,
@@ -774,16 +830,17 @@ void lttvwindowtraces_call_after_chunk(LttvAttributeName module_name,
   LttvHooks *after_chunk_tracefile=NULL;
   LttvHooks *event_hook=NULL;
   LttvHooksById *event_hook_by_id=NULL;
-  LttvTracesetStats *tss = LTTV_TRACESET_STATS(tsc);
  
-  g_assert(module_attribute =
+  module_attribute =
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
-                                LTTV_COMPUTATION)));
+                                LTTV_COMPUTATION));
+  g_assert(module_attribute);
 
-  g_assert(module_attribute =
+  module_attribute =
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
                                 LTTV_IATTRIBUTE(module_attribute),
-                                module_name)));
+                                module_name));
+  g_assert(module_attribute);
 
   type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
                                      LTTV_AFTER_CHUNK_TRACESET,
@@ -836,9 +893,10 @@ void lttvwindowtraces_set_in_progress(LttvAttributeName module_name,
   LttvAttribute *attribute = lttv_trace_attribute(trace);
   LttvAttributeValue value;
 
-  g_assert(attribute = 
+  attribute = 
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
-                                module_name)));
+                                module_name));
+  g_assert(attribute);
  
   value = lttv_iattribute_add(LTTV_IATTRIBUTE(attribute),
                               LTTV_IN_PROGRESS,
@@ -852,24 +910,26 @@ void lttvwindowtraces_unset_in_progress(LttvAttributeName module_name,
 {
   LttvAttribute *attribute = lttv_trace_attribute(trace);
 
-  g_assert(attribute = 
+  attribute = 
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
-                                module_name)));
+                                module_name));
+  g_assert(attribute);
  
   lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
                          LTTV_IN_PROGRESS);
 }
 
-gboolean lttvwindowtraces_get_in_progress(LttvAttributeName module_name,
+__EXPORT gboolean lttvwindowtraces_get_in_progress(LttvAttributeName module_name,
                                           LttvTrace *trace)
 {
   LttvAttribute *attribute = lttv_trace_attribute(trace);
   LttvAttributeType type;
   LttvAttributeValue value;
 
-  g_assert(attribute = 
+  attribute = 
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
-                                module_name)));
+                                module_name));
+  g_assert(attribute);
  
   type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
                                      LTTV_IN_PROGRESS,
@@ -887,9 +947,10 @@ void lttvwindowtraces_set_ready(LttvAttributeName module_name,
   LttvAttribute *attribute = lttv_trace_attribute(trace);
   LttvAttributeValue value;
 
-  g_assert(attribute = 
+  attribute = 
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
-                                module_name)));
+                                module_name));
+  g_assert(attribute);
  
   value = lttv_iattribute_add(LTTV_IATTRIBUTE(attribute),
                               LTTV_READY,
@@ -903,24 +964,26 @@ void lttvwindowtraces_unset_ready(LttvAttributeName module_name,
 {
   LttvAttribute *attribute = lttv_trace_attribute(trace);
 
-  g_assert(attribute = 
+  attribute = 
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
-                                module_name)));
+                                module_name));
+  g_assert(attribute);
  
   lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
                          LTTV_READY);
 }
 
-gboolean lttvwindowtraces_get_ready(LttvAttributeName module_name,
+__EXPORT gboolean lttvwindowtraces_get_ready(LttvAttributeName module_name,
                                     LttvTrace *trace)
 {
   LttvAttribute *attribute = lttv_trace_attribute(trace);
   LttvAttributeType type;
   LttvAttributeValue value;
 
-  g_assert(attribute = 
+  attribute = 
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
-                                module_name)));
+                                module_name));
+  g_assert(attribute);
  
   type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
                                      LTTV_READY,
@@ -932,6 +995,12 @@ gboolean lttvwindowtraces_get_ready(LttvAttributeName module_name,
     return TRUE;
 }
 
+static gint find_window_widget(MainWindow *a, GtkWidget *b)
+{
+  if(a->mwindow == b) return 0;
+  else return -1;
+}
+
 
 /* lttvwindowtraces_process_pending_requests
  * 
@@ -956,6 +1025,8 @@ gboolean lttvwindowtraces_process_pending_requests(LttvTrace *trace)
 
   if(trace == NULL)
     return FALSE;
+
+  if(lttvwindow_preempt_count > 0) return TRUE;
    
   attribute = lttv_trace_attribute(trace);
   
@@ -1070,15 +1141,17 @@ gboolean lttvwindowtraces_process_pending_requests(LttvTrace *trace)
           /* Get before request hook */
           LttvAttribute *module_attribute;
 
-          g_assert(module_attribute =
+          module_attribute =
               LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
                                  LTTV_IATTRIBUTE(g_attribute),
-                                 LTTV_COMPUTATION)));
+                                 LTTV_COMPUTATION));
+          g_assert(module_attribute);
 
-          g_assert(module_attribute =
+          module_attribute =
               LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
                                         LTTV_IATTRIBUTE(module_attribute),
-                                        bg_req->module_name)));
+                                        bg_req->module_name));
+          g_assert(module_attribute);
           
           type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
                                              LTTV_BEFORE_REQUEST,
@@ -1277,31 +1350,51 @@ gboolean lttvwindowtraces_process_pending_requests(LttvTrace *trace)
             /* Get after request hook */
             LttvAttribute *module_attribute;
 
-            g_assert(module_attribute =
+            module_attribute =
                 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
                                    LTTV_IATTRIBUTE(g_attribute),
-                                   LTTV_COMPUTATION)));
+                                   LTTV_COMPUTATION));
+            g_assert(module_attribute);
 
-            g_assert(module_attribute =
+            module_attribute =
                 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
                                           LTTV_IATTRIBUTE(module_attribute),
-                                          bg_req->module_name)));
+                                          bg_req->module_name));
+	    g_assert(module_attribute);
             
             type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
                                                LTTV_AFTER_REQUEST,
                                                &value);
             g_assert(type == LTTV_POINTER);
             LttvHooks *after_request = (LttvHooks*)*(value.v_pointer);
-
-            if(after_request != NULL) lttv_hooks_call(after_request, tsc);
+            {
+              struct sum_traceset_closure t_closure;
+	      t_closure.tss = (LttvTracesetStats*)tsc;
+	      t_closure.current_time = ltt_time_infinite;
+              if(after_request != NULL) lttv_hooks_call(after_request,
+	        &t_closure);
+            }
             
             if(bg_req->dialog != NULL)
               gtk_widget_destroy(bg_req->dialog);
+            GtkWidget *parent_window;
+            if(g_slist_find_custom(g_main_window_list,
+                  bg_req->parent_window,
+                  (GCompareFunc)find_window_widget))
+              parent_window = GTK_WIDGET(bg_req->parent_window);
+            else
+              parent_window = NULL;
+
             GtkWidget *dialog = 
-              gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, 
+              gtk_message_dialog_new(GTK_WINDOW(parent_window),
+                GTK_DIALOG_DESTROY_WITH_PARENT,
+                GTK_MESSAGE_INFO, GTK_BUTTONS_OK, 
                 "Background computation %s finished for trace %s", 
                 g_quark_to_string(bg_req->module_name),
                 g_quark_to_string(ltt_trace_name(lttv_trace(bg_req->trace))));
+            if(parent_window != NULL)
+              gtk_window_set_transient_for(GTK_WINDOW(dialog),
+                  GTK_WINDOW(parent_window));
             g_signal_connect_swapped (dialog, "response",
                 G_CALLBACK (gtk_widget_destroy),
                 dialog);
@@ -1421,85 +1514,101 @@ void lttvwindowtraces_register_computation_hooks(LttvAttributeName module_name,
   LttvAttribute *g_attribute = lttv_global_attributes();
   LttvAttribute *attribute;
   LttvAttributeValue value;
+  gboolean result;
 
-  g_assert(attribute = 
+  attribute = 
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
-                                LTTV_COMPUTATION)));
+                                LTTV_COMPUTATION));
+  g_assert(attribute);
 
-  g_assert(attribute = 
+  attribute = 
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
-                                module_name)));
+                                module_name));
+  g_assert(attribute);
 
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_BEFORE_CHUNK_TRACESET,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
+
   *(value.v_pointer) = before_chunk_traceset;
   
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_BEFORE_CHUNK_TRACE,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
   *(value.v_pointer) = before_chunk_trace;
   
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_BEFORE_CHUNK_TRACEFILE,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
   *(value.v_pointer) = before_chunk_tracefile;
   
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_AFTER_CHUNK_TRACESET,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
   *(value.v_pointer) = after_chunk_traceset;
 
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_AFTER_CHUNK_TRACE,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
   *(value.v_pointer) = after_chunk_trace;
 
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_AFTER_CHUNK_TRACEFILE,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
   *(value.v_pointer) = after_chunk_tracefile;
 
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_BEFORE_REQUEST,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
   *(value.v_pointer) = before_request;
 
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_AFTER_REQUEST,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
   *(value.v_pointer) = after_request;
 
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_EVENT_HOOK,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
   *(value.v_pointer) = event_hook;
 
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_EVENT_HOOK_BY_ID,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
   *(value.v_pointer) = event_hook_by_id;
 
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_HOOK_ADDER,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
   *(value.v_pointer) = hook_adder;
 
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_HOOK_REMOVER,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
   *(value.v_pointer) = hook_remover;
 
 }
@@ -1517,20 +1626,22 @@ void lttvwindowtraces_register_computation_hooks(LttvAttributeName module_name,
 void lttvwindowtraces_unregister_requests(LttvAttributeName module_name)
 {
   guint i;
+  gboolean result;
 
   for(i=0;i<lttvwindowtraces_get_number();i++) {
     LttvTrace *trace_v = lttvwindowtraces_get_trace(i);
     g_assert(trace_v != NULL);
-    LttTrace *trace;
     LttvAttribute *attribute = lttv_trace_attribute(trace_v);
     LttvAttributeValue value;
     GSList **queue, **current;
     GSList *iter;
     
-    g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+    result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                   LTTV_REQUESTS_QUEUE,
                                   LTTV_POINTER,
-                                  &value));
+                                  &value);
+    g_assert(result);
+
     queue = (GSList**)(value.v_pointer);
     
     iter = *queue;
@@ -1559,10 +1670,12 @@ void lttvwindowtraces_unregister_requests(LttvAttributeName module_name)
     }
     
         
-    g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+    result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                   LTTV_REQUESTS_CURRENT,
                                   LTTV_POINTER,
-                                  &value));
+                                  &value);
+    g_assert(result);
+
     current = (GSList**)(value.v_pointer);
     
     iter = *current;
@@ -1609,107 +1722,134 @@ void lttvwindowtraces_unregister_computation_hooks
   LttvAttribute *g_attribute = lttv_global_attributes();
   LttvAttribute *attribute;
   LttvAttributeValue value;
+  gboolean result;
 
-  g_assert(attribute = 
+  attribute = 
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
-                                LTTV_COMPUTATION)));
-  g_assert(attribute = 
-      LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
-                                module_name)));
+                                LTTV_COMPUTATION));
+  g_assert(attribute);
 
+  attribute = 
+      LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
+                                module_name));
+  g_assert(attribute);
 
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_BEFORE_CHUNK_TRACESET,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
+
   LttvHooks *before_chunk_traceset = (LttvHooks*)*(value.v_pointer);
   if(before_chunk_traceset != NULL)
     lttv_hooks_destroy(before_chunk_traceset);
   
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_BEFORE_CHUNK_TRACE,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
+
   LttvHooks *before_chunk_trace = (LttvHooks*)*(value.v_pointer);
   if(before_chunk_trace != NULL)
     lttv_hooks_destroy(before_chunk_trace);
   
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_BEFORE_CHUNK_TRACEFILE,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
+
   LttvHooks *before_chunk_tracefile = (LttvHooks*)*(value.v_pointer);
   if(before_chunk_tracefile != NULL)
     lttv_hooks_destroy(before_chunk_tracefile);
   
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_AFTER_CHUNK_TRACESET,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
+
   LttvHooks *after_chunk_traceset = (LttvHooks*)*(value.v_pointer);
   if(after_chunk_traceset != NULL)
     lttv_hooks_destroy(after_chunk_traceset);
  
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_AFTER_CHUNK_TRACE,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
+
   LttvHooks *after_chunk_trace = (LttvHooks*)*(value.v_pointer);
   if(after_chunk_trace != NULL)
     lttv_hooks_destroy(after_chunk_trace);
  
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_AFTER_CHUNK_TRACEFILE,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
+
   LttvHooks *after_chunk_tracefile = (LttvHooks*)*(value.v_pointer);
   if(after_chunk_tracefile != NULL)
     lttv_hooks_destroy(after_chunk_tracefile);
  
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_BEFORE_REQUEST,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
+
   LttvHooks *before_request = (LttvHooks*)*(value.v_pointer);
   if(before_request != NULL)
     lttv_hooks_destroy(before_request);
  
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_AFTER_REQUEST,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
+
   LttvHooks *after_request = (LttvHooks*)*(value.v_pointer);
   if(after_request != NULL)
     lttv_hooks_destroy(after_request);
  
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_EVENT_HOOK,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
+
   LttvHooks *event_hook = (LttvHooks*)*(value.v_pointer);
   if(event_hook != NULL)
     lttv_hooks_destroy(event_hook);
  
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_EVENT_HOOK_BY_ID,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
+
   LttvHooksById *event_hook_by_id = (LttvHooksById*)*(value.v_pointer);
   if(event_hook_by_id != NULL)
     lttv_hooks_by_id_destroy(event_hook_by_id);
  
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_HOOK_ADDER,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
+
   LttvHooks *hook_adder = (LttvHooks*)*(value.v_pointer);
   if(hook_adder != NULL)
     lttv_hooks_destroy(hook_adder);
  
-  g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+  result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
                                 LTTV_HOOK_REMOVER,
                                 LTTV_POINTER,
-                                &value));
+                                &value);
+  g_assert(result);
+
   LttvHooks *hook_remover = (LttvHooks*)*(value.v_pointer);
   if(hook_remover != NULL)
     lttv_hooks_destroy(hook_remover);
@@ -1744,9 +1884,10 @@ void lttvwindowtraces_unregister_computation_hooks
                                      LTTV_HOOK_REMOVER);
 
   /* finally, remove module name */
-  g_assert(attribute = 
+  attribute = 
       LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
-                                LTTV_COMPUTATION)));
+                                LTTV_COMPUTATION));
+  g_assert(attribute);
   lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
                                      module_name);