ltt/branches/poly/lttv/modules/gui/lttvwindow/lttvwindow/callbacks.c

   1 /* This file is part of the Linux Trace Toolkit viewer
   2  * Copyright (C) 2003-2004 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 #ifdef HAVE_CONFIG_H
  20 #  include <config.h>
  21 #endif
  22
  23 #include <limits.h> // for PATH_MAX
  24 #include <stdlib.h>
  25
  26 #include <gtk/gtk.h>
  27
  28 #include "callbacks.h"
  29 #include "interface.h"
  30 #include "support.h"
  31 #include <ltt/trace.h>
  32 #include <ltt/facility.h>
  33 #include <ltt/time.h>
  34 #include <ltt/event.h>
  35 #include <lttv/lttv.h>
  36 #include <lttv/module.h>
  37 #include <lttv/iattribute.h>
  38 #include <lttv/stats.h>
  39 #include <lttvwindow/mainwindow.h>
  40 #include <lttvwindow/mainwindow-private.h>
  41 #include <lttvwindow/menu.h>
  42 #include <lttvwindow/toolbar.h>
  43 #include <lttvwindow/lttvwindow.h>
  44 #include <lttvwindow/lttvwindowtraces.h>
  45 #include <lttvwindow/gtkdirsel.h>
  46 #include <lttvwindow/lttvfilter.h>
  47
  48
  49 #define DEFAULT_TIME_WIDTH_S   1
  50
  51 extern LttvTrace *g_init_trace ;
  52
  53
  54 /** Array containing instanced objects. */
  55 extern GSList * g_main_window_list;
  56
  57 /** MD : keep old directory. */
  58 static char remember_plugins_dir[PATH_MAX] = "";
  59 static char remember_trace_dir[PATH_MAX] = "";
  60
  61
  62 MainWindow * get_window_data_struct(GtkWidget * widget);
  63 char * get_unload_module(char ** loaded_module_name, int nb_module);
  64 char * get_remove_trace(char ** all_trace_name, int nb_trace);
  65 char * get_selection(char ** all_name, int nb, char *title, char * column_title);
  66 gboolean get_filter_selection(LttvTracesetSelector *s, char *title, char * column_title);
  67 Tab* create_tab(MainWindow * mw, Tab *copy_tab,
  68                   GtkNotebook * notebook, char * label);
  69
  70 static void insert_viewer(GtkWidget* widget, lttvwindow_viewer_constructor constructor);
  71 void update_filter(LttvTracesetSelector *s,  GtkTreeStore *store );
  72
  73 void checkbox_changed(GtkTreeView *treeview,
  74                       GtkTreePath *arg1,
  75                       GtkTreeViewColumn *arg2,
  76                       gpointer user_data);
  77 void remove_trace_from_traceset_selector(GtkMultiVPaned * paned, unsigned i);
  78 void add_trace_into_traceset_selector(GtkMultiVPaned * paned, LttTrace * trace);
  79 Tab *create_new_tab(GtkWidget* widget, gpointer user_data);
  80
  81 LttvTracesetSelector * construct_traceset_selector(LttvTraceset * traceset);
  82
  83 static gboolean lttvwindow_process_pending_requests(Tab *tab);
  84
  85 enum {
  86   CHECKBOX_COLUMN,
  87   NAME_COLUMN,
  88   TOTAL_COLUMNS
  89 };
  90
  91 enum
  92 {
  93   MODULE_COLUMN,
  94   N_COLUMNS
  95 };
  96
  97 /* Construct a selector(filter), which will be associated with a viewer,
  98  * and provides an interface for user to select interested events and traces
  99  */
 100
 101 LttvTracesetSelector * construct_traceset_selector(LttvTraceset * traceset)
 102 {
 103   LttvTracesetSelector  * s;
 104   LttvTraceSelector     * trace;
 105   LttvTracefileSelector * tracefile;
 106   LttvEventtypeSelector * eventtype;
 107   int i, j, k, m;
 108   int nb_trace, nb_tracefile, nb_control, nb_per_cpu, nb_facility, nb_event;
 109   LttvTrace * trace_v;
 110   LttTrace  * t;
 111   LttTracefile *tf;
 112   LttFacility * fac;
 113   LttEventType * et;
 114
 115   s = lttv_traceset_selector_new(lttv_traceset_name(traceset));
 116   nb_trace = lttv_traceset_number(traceset);
 117   for(i=0;i<nb_trace;i++){
 118     trace_v = lttv_traceset_get(traceset, i);
 119     t       = lttv_trace(trace_v);
 120     trace   = lttv_trace_selector_new(t);
 121     lttv_traceset_selector_trace_add(s, trace);
 122
 123     nb_facility = ltt_trace_facility_number(t);
 124     for(k=0;k<nb_facility;k++){
 125       fac = ltt_trace_facility_get(t,k);
 126       nb_event = (int) ltt_facility_eventtype_number(fac);
 127       for(m=0;m<nb_event;m++){
 128         et = ltt_facility_eventtype_get(fac,m);
 129         eventtype = lttv_eventtype_selector_new(et);
 130         lttv_trace_selector_eventtype_add(trace, eventtype);
 131       }
 132     }
 133
 134     nb_control = ltt_trace_control_tracefile_number(t);
 135     nb_per_cpu = ltt_trace_per_cpu_tracefile_number(t);
 136     nb_tracefile = nb_control + nb_per_cpu;
 137
 138     for(j = 0 ; j < nb_tracefile ; j++) {
 139       if(j < nb_control)
 140         tf = ltt_trace_control_tracefile_get(t, j);
 141       else
 142         tf = ltt_trace_per_cpu_tracefile_get(t, j - nb_control);
 143       tracefile = lttv_tracefile_selector_new(tf);
 144       lttv_trace_selector_tracefile_add(trace, tracefile);
 145       lttv_eventtype_selector_copy(trace, tracefile);
 146     }
 147   }
 148   return s;
 149 }
 150
 151
 152 /* insert_viewer function constructs an instance of a viewer first,
 153  * then inserts the widget of the instance into the container of the
 154  * main window
 155  */
 156
 157 void
 158 insert_viewer_wrap(GtkWidget *menuitem, gpointer user_data)
 159 {
 160   guint val = 20;
 161
 162   insert_viewer((GtkWidget*)menuitem, (lttvwindow_viewer_constructor)user_data);
 163   //  selected_hook(&val);
 164 }
 165
 166
 167 /* internal functions */
 168 void insert_viewer(GtkWidget* widget, lttvwindow_viewer_constructor constructor)
 169 {
 170   GtkMultiVPaned * multi_vpaned;
 171   MainWindow * mw_data = get_window_data_struct(widget);
 172   GtkWidget * notebook = lookup_widget(widget, "MNotebook");
 173   GtkWidget * viewer;
 174   LttvTracesetSelector  * s;
 175   TimeInterval * time_interval;
 176   GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
 177                       gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
 178   Tab *tab;
 179
 180   if(!page) {
 181     tab = create_new_tab(widget, NULL);
 182   } else {
 183     tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
 184   }
 185
 186   multi_vpaned = tab->multi_vpaned;
 187
 188   s = construct_traceset_selector(tab->traceset_info->traceset);
 189   viewer = (GtkWidget*)constructor(tab, s, "Traceset_Selector");
 190   if(viewer)
 191   {
 192     gtk_multi_vpaned_widget_add(multi_vpaned, viewer);
 193     // We unref here, because it is now referenced by the multi_vpaned!
 194     g_object_unref(G_OBJECT(viewer));
 195
 196     // The viewer will show itself when it receives a show notify
 197     // So we call the show notify hooks here. It will
 198     // typically add hooks for reading, we call process trace, and the
 199     // end of reading hook will call gtk_widget_show and unregister the
 200     // hooks.
 201     // Note that show notify gets the time_requested through the call_data.
 202     //show_viewer(mw_data);
 203     // in expose now call_pending_read_hooks(mw_data);
 204   }
 205 }
 206
 207
 208 /* get_label function is used to get user input, it displays an input
 209  * box, which allows user to input a string
 210  */
 211
 212 void get_label_string (GtkWidget * text, gchar * label)
 213 {
 214   GtkEntry * entry = (GtkEntry*)text;
 215   if(strlen(gtk_entry_get_text(entry))!=0)
 216     strcpy(label,gtk_entry_get_text(entry));
 217 }
 218
 219 gboolean get_label(MainWindow * mw, gchar * str, gchar* dialogue_title, gchar * label_str)
 220 {
 221   GtkWidget * dialogue;
 222   GtkWidget * text;
 223   GtkWidget * label;
 224   gint id;
 225
 226   dialogue = gtk_dialog_new_with_buttons(dialogue_title,NULL,
 227                                          GTK_DIALOG_MODAL,
 228                                          GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
 229                                          GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
 230                                          NULL);
 231
 232   label = gtk_label_new(label_str);
 233   gtk_widget_show(label);
 234
 235   text = gtk_entry_new();
 236   gtk_widget_show(text);
 237
 238   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), label,TRUE, TRUE,0);
 239   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), text,FALSE, FALSE,0);
 240
 241   id = gtk_dialog_run(GTK_DIALOG(dialogue));
 242   switch(id){
 243     case GTK_RESPONSE_ACCEPT:
 244       get_label_string(text,str);
 245       gtk_widget_destroy(dialogue);
 246       break;
 247     case GTK_RESPONSE_REJECT:
 248     default:
 249       gtk_widget_destroy(dialogue);
 250       return FALSE;
 251   }
 252   return TRUE;
 253 }
 254
 255
 256 /* get_window_data_struct function is actually a lookup function,
 257  * given a widget which is in the tree of the main window, it will
 258  * return the MainWindow data structure associated with main window
 259  */
 260
 261 MainWindow * get_window_data_struct(GtkWidget * widget)
 262 {
 263   GtkWidget * mw;
 264   MainWindow * mw_data;
 265
 266   mw = lookup_widget(widget, "MWindow");
 267   if(mw == NULL){
 268     g_printf("Main window does not exist\n");
 269     return NULL;
 270   }
 271
 272   mw_data = (MainWindow *) g_object_get_data(G_OBJECT(mw),"main_window_data");
 273   if(mw_data == NULL){
 274     g_printf("Main window data does not exist\n");
 275     return NULL;
 276   }
 277   return mw_data;
 278 }
 279
 280
 281 /* create_new_window function, just constructs a new main window
 282  */
 283
 284 void create_new_window(GtkWidget* widget, gpointer user_data, gboolean clone)
 285 {
 286   MainWindow * parent = get_window_data_struct(widget);
 287
 288   if(clone){
 289     g_printf("Clone : use the same traceset\n");
 290     construct_main_window(parent);
 291   }else{
 292     g_printf("Empty : traceset is set to NULL\n");
 293     construct_main_window(NULL);
 294   }
 295 }
 296
 297
 298 /* move_*_viewer functions move the selected view up/down in
 299  * the current tab
 300  */
 301
 302 void move_up_viewer(GtkWidget * widget, gpointer user_data)
 303 {
 304   MainWindow * mw = get_window_data_struct(widget);
 305   GtkWidget * notebook = lookup_widget(widget, "MNotebook");
 306
 307   GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
 308                       gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
 309
 310   Tab *tab;
 311
 312   if(!page) {
 313     return;
 314   } else {
 315     tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
 316   }
 317
 318   gtk_multi_vpaned_widget_move_up(tab->multi_vpaned);
 319 }
 320
 321 void move_down_viewer(GtkWidget * widget, gpointer user_data)
 322 {
 323   MainWindow * mw = get_window_data_struct(widget);
 324   GtkWidget * notebook = lookup_widget(widget, "MNotebook");
 325
 326   GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
 327                       gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
 328   Tab *tab;
 329
 330   if(!page) {
 331     return;
 332   } else {
 333     tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
 334   }
 335
 336   gtk_multi_vpaned_widget_move_down(tab->multi_vpaned);
 337 }
 338
 339
 340 /* delete_viewer deletes the selected viewer in the current tab
 341  */
 342
 343 void delete_viewer(GtkWidget * widget, gpointer user_data)
 344 {
 345   MainWindow * mw = get_window_data_struct(widget);
 346   GtkWidget * notebook = lookup_widget(widget, "MNotebook");
 347
 348   GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
 349                       gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
 350   Tab *tab;
 351
 352   if(!page) {
 353     return;
 354   } else {
 355     tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
 356   }
 357
 358   gtk_multi_vpaned_widget_delete(tab->multi_vpaned);
 359 }
 360
 361
 362 /* open_traceset will open a traceset saved in a file
 363  * Right now, it is not finished yet, (not working)
 364  * FIXME
 365  */
 366
 367 void open_traceset(GtkWidget * widget, gpointer user_data)
 368 {
 369   char ** dir;
 370   gint id;
 371   LttvTraceset * traceset;
 372   MainWindow * mw_data = get_window_data_struct(widget);
 373   GtkFileSelection * file_selector =
 374     (GtkFileSelection *)gtk_file_selection_new("Select a traceset");
 375
 376   gtk_file_selection_hide_fileop_buttons(file_selector);
 377
 378   id = gtk_dialog_run(GTK_DIALOG(file_selector));
 379   switch(id){
 380     case GTK_RESPONSE_ACCEPT:
 381     case GTK_RESPONSE_OK:
 382       dir = gtk_file_selection_get_selections (file_selector);
 383       traceset = lttv_traceset_load(dir[0]);
 384       g_printf("Open a trace set %s\n", dir[0]);
 385       //Not finished yet
 386       g_strfreev(dir);
 387     case GTK_RESPONSE_REJECT:
 388     case GTK_RESPONSE_CANCEL:
 389     default:
 390       gtk_widget_destroy((GtkWidget*)file_selector);
 391       break;
 392   }
 393
 394 }
 395
 396
 397 /* lttvwindow_process_pending_requests
 398  *
 399  * This internal function gets called by g_idle, taking care of the pending
 400  * requests. It is responsible for concatenation of time intervals and position
 401  * requests. It does it with the following algorithm organizing process traceset
 402  * calls. Here is the detailed description of the way it works :
 403  *
 404  * - Events Requests Servicing Algorithm
 405  *
 406  *   Data structures necessary :
 407  *
 408  *   List of requests added to context : list_in
 409  *   List of requests not added to context : list_out
 410  *
 411  *   Initial state :
 412  *
 413  *   list_in : empty
 414  *   list_out : many events requests
 415  *
 416  *  FIXME : insert rest of algorithm here
 417  *
 418  */
 419
 420 #define list_out tab->events_requests
 421
 422 gboolean lttvwindow_process_pending_requests(Tab *tab)
 423 {
 424   unsigned max_nb_events;
 425   GdkWindow * win;
 426   GdkCursor * new;
 427   GtkWidget* widget;
 428   LttvTracesetContext *tsc;
 429   LttvTracefileContext *tfc;
 430   GSList *list_in = NULL;
 431   LttTime end_time;
 432   guint end_nb_events;
 433   guint count;
 434   LttvTracesetContextPosition *end_position;
 435
 436   if(tab == NULL)
 437     return FALSE;
 438
 439   /* There is no events requests pending : we should never have been called! */
 440   g_assert(g_slist_length(list_out) != 0);
 441
 442   tsc = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context);
 443
 444   //set the cursor to be X shape, indicating that the computer is busy in doing its job
 445 #if 0
 446   new = gdk_cursor_new(GDK_X_CURSOR);
 447   widget = lookup_widget(tab->mw->mwindow, "MToolbar1");
 448   win = gtk_widget_get_parent_window(widget);
 449   gdk_window_set_cursor(win, new);
 450   gdk_cursor_unref(new);
 451   gdk_window_stick(win);
 452   gdk_window_unstick(win);
 453 #endif //0
 454
 455   g_debug("SIZE events req len  : %d", g_slist_length(list_out));
 456
 457   /* Preliminary check for no trace in traceset */
 458   /* Unregister the routine if empty, empty list_out too */
 459   if(lttv_traceset_number(tsc->ts) == 0) {
 460
 461     /* - For each req in list_out */
 462     GSList *iter = list_out;
 463
 464     while(iter != NULL) {
 465
 466       gboolean remove = FALSE;
 467       gboolean free_data = FALSE;
 468       EventsRequest *events_request = (EventsRequest *)iter->data;
 469
 470       /* - Call end request for req */
 471       if(events_request->servicing == TRUE)
 472         lttv_hooks_call(events_request->after_request, (gpointer)tsc);
 473
 474       /* - remove req from list_out */
 475       /* Destroy the request */
 476       remove = TRUE;
 477       free_data = TRUE;
 478
 479       /* Go to next */
 480       if(remove)
 481       {
 482         GSList *remove_iter = iter;
 483
 484         iter = g_slist_next(iter);
 485         if(free_data) g_free(remove_iter->data);
 486         list_out = g_slist_remove_link(list_out, remove_iter);
 487       } else { // not remove
 488         iter = g_slist_next(iter);
 489       }
 490     }
 491   }
 492
 493   /* Events processing algorithm implementation */
 494   /* A. Servicing loop */
 495   while( (g_slist_length(list_in) != 0 || g_slist_length(list_out) != 0)) {
 496      /*    && !gtk_events_pending() )  */
 497
 498     /* 1. If list_in is empty (need a seek) */
 499     if( g_slist_length(list_in) ==  0 ) {
 500
 501       /* list in is empty, need a seek */
 502       {
 503         /* 1.1 Add requests to list_in */
 504         GSList *ltime = NULL;
 505         GSList *lpos = NULL;
 506         GSList *iter = NULL;
 507
 508         /* 1.1.1 Find all time requests with the lowest start time in list_out
 509          * (ltime)
 510          */
 511         if(g_slist_length(list_out) > 0)
 512           ltime = g_slist_append(ltime, g_slist_nth_data(list_out, 0));
 513         for(iter=g_slist_nth(list_out,1);iter!=NULL;iter=g_slist_next(iter)) {
 514           /* Find all time requests with the lowest start time in list_out */
 515           guint index_ltime = g_array_index(ltime, guint, 0);
 516           EventsRequest *event_request_ltime = (EventsRequest*)g_slist_nth_data(ltime, 0);
 517           EventsRequest *event_request_list_out = (EventsRequest*)iter->data;
 518
 519           int comp;
 520           comp = ltt_time_compare(event_request_ltime->start_time,
 521                                   event_request_list_out->start_time);
 522           if(comp == 0)
 523             ltime = g_slist_append(ltime, event_request_list_out);
 524           else if(comp > 0) {
 525             /* Remove all elements from ltime, and add current */
 526             while(ltime != NULL)
 527               ltime = g_slist_delete_link(ltime, g_slist_nth(ltime, 0));
 528             ltime = g_slist_append(ltime, event_request_list_out);
 529           }
 530         }
 531
 532         /* 1.1.2 Find all position requests with the lowest position in list_out
 533          * (lpos)
 534          */
 535         if(g_slist_length(list_out) > 0)
 536           lpos = g_slist_append(lpos, g_slist_nth_data(list_out, 0));
 537         for(iter=g_slist_nth(list_out,1);iter!=NULL;iter=g_slist_next(iter)) {
 538           /* Find all position requests with the lowest position in list_out */
 539           guint index_lpos = g_array_index(lpos, guint, 0);
 540           EventsRequest *event_request_lpos = (EventsRequest*)g_slist_nth_data(lpos, 0);
 541           EventsRequest *event_request_list_out = (EventsRequest*)iter->data;
 542
 543           int comp;
 544           if(event_request_lpos->start_position != NULL
 545               && event_request_list_out->start_position != NULL)
 546           {
 547             comp = lttv_traceset_context_pos_pos_compare
 548                                  (event_request_lpos->start_position,
 549                                   event_request_list_out->start_position);
 550           } else {
 551             comp = -1;
 552           }
 553           if(comp == 0)
 554             lpos = g_slist_append(lpos, event_request_list_out);
 555           else if(comp > 0) {
 556             /* Remove all elements from lpos, and add current */
 557             while(lpos != NULL)
 558               lpos = g_slist_delete_link(lpos, g_slist_nth(lpos, 0));
 559             lpos = g_slist_append(lpos, event_request_list_out);
 560           }
 561         }
 562
 563         /* 1.1.3 If lpos.start time < ltime */
 564         {
 565           EventsRequest *event_request_lpos = (EventsRequest*)g_slist_nth_data(lpos, 0);
 566           EventsRequest *event_request_ltime = (EventsRequest*)g_slist_nth_data(ltime, 0);
 567           LttTime lpos_start_time;
 568
 569           if(event_request_lpos != NULL
 570               && event_request_lpos->start_position != NULL) {
 571
 572             lpos_start_time = lttv_traceset_context_position_get_time(
 573                                       event_request_lpos->start_position);
 574             if(ltt_time_compare(lpos_start_time,
 575                                 event_request_ltime->start_time)<0) {
 576               /* Add lpos to list_in, remove them from list_out */
 577
 578               for(iter=lpos;iter!=NULL;iter=g_slist_next(iter)) {
 579                 /* Add to list_in */
 580                 EventsRequest *event_request_lpos =
 581                                       (EventsRequest*)iter->data;
 582
 583                 list_in = g_slist_append(list_in, event_request_lpos);
 584                 /* Remove from list_out */
 585                 list_out = g_slist_remove(list_out, event_request_lpos);
 586               }
 587             }
 588           } else {
 589             /* 1.1.4 (lpos.start time >= ltime) */
 590             /* Add ltime to list_in, remove them from list_out */
 591
 592             for(iter=ltime;iter!=NULL;iter=g_slist_next(iter)) {
 593               /* Add to list_in */
 594               EventsRequest *event_request_ltime =
 595                                     (EventsRequest*)iter->data;
 596
 597               list_in = g_slist_append(list_in, event_request_ltime);
 598               /* Remove from list_out */
 599               list_out = g_slist_remove(list_out, event_request_ltime);
 600             }
 601           }
 602         }
 603         g_slist_free(lpos);
 604         g_slist_free(ltime);
 605       }
 606
 607       /* 1.2 Seek */
 608       {
 609         tfc = lttv_traceset_context_get_current_tfc(tsc);
 610         g_assert(g_slist_length(list_in)>0);
 611         EventsRequest *events_request = g_slist_nth_data(list_in, 0);
 612         guint seek_count;
 613
 614         /* 1.2.1 If first request in list_in is a time request */
 615         if(events_request->start_position == NULL) {
 616           /* - If first req in list_in start time != current time */
 617           if(tfc == NULL || ltt_time_compare(events_request->start_time,
 618                               tfc->timestamp) != 0)
 619             /* - Seek to that time */
 620             g_debug("SEEK TIME : %lu, %lu", events_request->start_time.tv_sec,
 621               events_request->start_time.tv_nsec);
 622             //lttv_process_traceset_seek_time(tsc, events_request->start_time);
 623             lttv_state_traceset_seek_time_closest(LTTV_TRACESET_STATE(tsc),
 624                                                   events_request->start_time);
 625
 626             /* Process the traceset with only state hooks */
 627             seek_count =
 628                lttv_process_traceset_middle(tsc,
 629                                             events_request->start_time,
 630                                             G_MAXUINT, NULL);
 631
 632
 633         } else {
 634           LttTime pos_time;
 635           /* Else, the first request in list_in is a position request */
 636           /* If first req in list_in pos != current pos */
 637           g_assert(events_request->start_position != NULL);
 638           g_debug("SEEK POS time : %lu, %lu",
 639      lttv_traceset_context_position_get_time(events_request->start_position).tv_sec,
 640      lttv_traceset_context_position_get_time(events_request->start_position).tv_nsec);
 641
 642           g_debug("SEEK POS context time : %lu, %lu",
 643         lttv_traceset_context_get_current_tfc(tsc)->timestamp.tv_sec,
 644         lttv_traceset_context_get_current_tfc(tsc)->timestamp.tv_nsec);
 645           if(lttv_traceset_context_ctx_pos_compare(tsc,
 646                      events_request->start_position) != 0) {
 647             /* 1.2.2.1 Seek to that position */
 648             g_debug("SEEK POSITION");
 649             //lttv_process_traceset_seek_position(tsc, events_request->start_position);
 650             pos_time = lttv_traceset_context_position_get_time(events_request->start_position);
 651
 652             lttv_state_traceset_seek_time_closest(LTTV_TRACESET_STATE(tsc),
 653                                                   pos_time);
 654
 655             /* Process the traceset with only state hooks */
 656             seek_count =
 657                lttv_process_traceset_middle(tsc,
 658                                             ltt_time_infinite,
 659                                             G_MAXUINT,
 660                                             events_request->start_position);
 661
 662
 663           }
 664         }
 665       }
 666
 667       /* 1.3 Add hooks and call before request for all list_in members */
 668       {
 669         GSList *iter = NULL;
 670
 671         for(iter=list_in;iter!=NULL;iter=g_slist_next(iter)) {
 672           EventsRequest *events_request = (EventsRequest*)iter->data;
 673           /* 1.3.1 If !servicing */
 674           if(events_request->servicing == FALSE) {
 675             /* - begin request hooks called
 676              * - servicing = TRUE
 677              */
 678             lttv_hooks_call(events_request->before_request, (gpointer)tsc);
 679             events_request->servicing = TRUE;
 680           }
 681           /* 1.3.2 call before chunk
 682            * 1.3.3 events hooks added
 683            */
 684           lttv_process_traceset_begin(tsc, events_request->before_chunk_traceset,
 685                                            events_request->before_chunk_trace,
 686                                            events_request->before_chunk_tracefile,
 687                                            events_request->event,
 688                                            events_request->event_by_id);
 689         }
 690       }
 691     } else {
 692       /* 2. Else, list_in is not empty, we continue a read */
 693
 694       {
 695         /* 2.0 For each req of list_in */
 696         GSList *iter = list_in;
 697
 698         while(iter != NULL) {
 699
 700           EventsRequest *events_request = (EventsRequest *)iter->data;
 701
 702           /* - Call before chunk
 703            * - events hooks added
 704            */
 705           lttv_process_traceset_begin(tsc, events_request->before_chunk_traceset,
 706                                          events_request->before_chunk_trace,
 707                                          events_request->before_chunk_tracefile,
 708                                          events_request->event,
 709                                          events_request->event_by_id);
 710
 711           iter = g_slist_next(iter);
 712         }
 713       }
 714
 715       {
 716         GSList *iter = NULL;
 717         tfc = lttv_traceset_context_get_current_tfc(tsc);
 718
 719         /* 2.1 For each req of list_out */
 720         for(iter=list_out;iter!=NULL;iter=g_slist_next(iter)) {
 721           EventsRequest *events_request = (EventsRequest*)iter->data;
 722
 723           /* if req.start time == current context time
 724            * or req.start position == current position*/
 725           if(  ltt_time_compare(events_request->start_time,
 726                               tfc->timestamp) == 0
 727              ||
 728                (events_request->start_position != NULL
 729                &&
 730                lttv_traceset_context_ctx_pos_compare(tsc,
 731                        events_request->start_position) == 0)
 732              ) {
 733             /* - Add to list_in, remove from list_out */
 734             list_in = g_slist_append(list_in, events_request);
 735             list_out = g_slist_remove(list_out, events_request);
 736
 737             /* - If !servicing */
 738             if(events_request->servicing == FALSE) {
 739               /* - begin request hooks called
 740                * - servicing = TRUE
 741                */
 742               lttv_hooks_call(events_request->before_request, (gpointer)tsc);
 743               events_request->servicing = TRUE;
 744             }
 745             /* call before chunk
 746              * events hooks added
 747              */
 748             lttv_process_traceset_begin(tsc, events_request->before_chunk_traceset,
 749                                              events_request->before_chunk_trace,
 750                                              events_request->before_chunk_tracefile,
 751                                              events_request->event,
 752                                              events_request->event_by_id);
 753           }
 754         }
 755       }
 756     }
 757
 758     /* 3. Find end criterions */
 759     {
 760       /* 3.1 End time */
 761       GSList *iter;
 762
 763       /* 3.1.1 Find lowest end time in list_in */
 764       g_assert(g_slist_length(list_in)>0);
 765       end_time = ((EventsRequest*)g_slist_nth_data(list_in,0))->end_time;
 766
 767       for(iter=g_slist_nth(list_in,1);iter!=NULL;iter=g_slist_next(iter)) {
 768         EventsRequest *events_request = (EventsRequest*)iter->data;
 769
 770         if(ltt_time_compare(events_request->end_time,
 771                             end_time) < 0)
 772           end_time = events_request->end_time;
 773       }
 774
 775       /* 3.1.2 Find lowest start time in list_out */
 776       for(iter=list_out;iter!=NULL;iter=g_slist_next(iter)) {
 777         EventsRequest *events_request = (EventsRequest*)iter->data;
 778
 779         if(ltt_time_compare(events_request->start_time,
 780                             end_time) < 0)
 781           end_time = events_request->start_time;
 782       }
 783     }
 784
 785     {
 786       /* 3.2 Number of events */
 787
 788       /* 3.2.1 Find lowest number of events in list_in */
 789       GSList *iter;
 790
 791       end_nb_events = ((EventsRequest*)g_slist_nth_data(list_in,0))->num_events;
 792
 793       for(iter=g_slist_nth(list_in,1);iter!=NULL;iter=g_slist_next(iter)) {
 794         EventsRequest *events_request = (EventsRequest*)iter->data;
 795
 796         if(events_request->num_events < end_nb_events)
 797           end_nb_events = events_request->num_events;
 798       }
 799
 800       /* 3.2.2 Use min(CHUNK_NUM_EVENTS, min num events in list_in) as
 801        * num_events */
 802
 803       end_nb_events = MIN(CHUNK_NUM_EVENTS, end_nb_events);
 804     }
 805
 806     {
 807       /* 3.3 End position */
 808
 809       /* 3.3.1 Find lowest end position in list_in */
 810       GSList *iter;
 811
 812       end_position =((EventsRequest*)g_slist_nth_data(list_in,0))->end_position;
 813
 814       for(iter=g_slist_nth(list_in,1);iter!=NULL;iter=g_slist_next(iter)) {
 815         EventsRequest *events_request = (EventsRequest*)iter->data;
 816
 817         if(events_request->end_position != NULL && end_position != NULL &&
 818             lttv_traceset_context_pos_pos_compare(events_request->end_position,
 819                                                  end_position) <0)
 820           end_position = events_request->end_position;
 821       }
 822     }
 823
 824     {
 825       /* 3.3.2 Find lowest start position in list_out */
 826       GSList *iter;
 827
 828       for(iter=list_out;iter!=NULL;iter=g_slist_next(iter)) {
 829         EventsRequest *events_request = (EventsRequest*)iter->data;
 830
 831         if(events_request->end_position != NULL && end_position != NULL &&
 832             lttv_traceset_context_pos_pos_compare(events_request->end_position,
 833                                                  end_position) <0)
 834           end_position = events_request->end_position;
 835       }
 836     }
 837
 838     {
 839       /* 4. Call process traceset middle */
 840       g_critical("Calling process traceset middle with %p, %lu sec %lu nsec, %lu nb ev, %p end pos", tsc, end_time.tv_sec, end_time.tv_nsec, end_nb_events, end_position);
 841       count = lttv_process_traceset_middle(tsc, end_time, end_nb_events, end_position);
 842
 843       tfc = lttv_traceset_context_get_current_tfc(tsc);
 844       g_critical("Context time after middle : %lu, %lu", tfc->timestamp.tv_sec,
 845                                                         tfc->timestamp.tv_nsec);
 846
 847     }
 848     {
 849       /* 5. After process traceset middle */
 850       tfc = lttv_traceset_context_get_current_tfc(tsc);
 851
 852       /* - if current context time > traceset.end time */
 853       if(tfc == NULL || ltt_time_compare(tfc->timestamp,
 854                                          tsc->time_span.end_time) > 0) {
 855         /* - For each req in list_in */
 856         GSList *iter = list_in;
 857
 858         while(iter != NULL) {
 859
 860           gboolean remove = FALSE;
 861           gboolean free_data = FALSE;
 862           EventsRequest *events_request = (EventsRequest *)iter->data;
 863
 864           /* - Remove events hooks for req
 865            * - Call end chunk for req
 866            */
 867           lttv_process_traceset_end(tsc, events_request->after_chunk_traceset,
 868                                          events_request->after_chunk_trace,
 869                                          events_request->after_chunk_tracefile,
 870                                          events_request->event,
 871                                          events_request->event_by_id);
 872           /* - Call end request for req */
 873           lttv_hooks_call(events_request->after_request, (gpointer)tsc);
 874
 875           /* - remove req from list_in */
 876           /* Destroy the request */
 877           remove = TRUE;
 878           free_data = TRUE;
 879
 880           /* Go to next */
 881           if(remove)
 882           {
 883             GSList *remove_iter = iter;
 884
 885             iter = g_slist_next(iter);
 886             if(free_data) g_free(remove_iter->data);
 887             list_in = g_slist_remove_link(list_in, remove_iter);
 888           } else { // not remove
 889             iter = g_slist_next(iter);
 890           }
 891         }
 892       }
 893       {
 894         /* 5.1 For each req in list_in */
 895         GSList *iter = list_in;
 896
 897         while(iter != NULL) {
 898
 899           gboolean remove = FALSE;
 900           gboolean free_data = FALSE;
 901           EventsRequest *events_request = (EventsRequest *)iter->data;
 902
 903           /* - Remove events hooks for req
 904            * - Call end chunk for req
 905            */
 906           lttv_process_traceset_end(tsc, events_request->after_chunk_traceset,
 907                                          events_request->after_chunk_trace,
 908                                          events_request->after_chunk_tracefile,
 909                                          events_request->event,
 910                                          events_request->event_by_id);
 911
 912           /* - req.num -= count */
 913           g_assert(events_request->num_events >= count);
 914           events_request->num_events -= count;
 915
 916           g_assert(tfc != NULL);
 917           /* - if req.num == 0
 918            *   or
 919            *     current context time >= req.end time
 920            *   or
 921            *     req.end pos == current pos
 922            *   or
 923            *     req.stop_flag == TRUE
 924            */
 925           if(   events_request->num_events == 0
 926               ||
 927                 events_request->stop_flag == TRUE
 928               ||
 929                 ltt_time_compare(tfc->timestamp,
 930                                          events_request->end_time) >= 0
 931               ||
 932                   (events_request->end_position != NULL
 933                  &&
 934                   lttv_traceset_context_ctx_pos_compare(tsc,
 935                             events_request->end_position) != 0)
 936
 937               ) {
 938             g_assert(events_request->servicing == TRUE);
 939             /* - Call end request for req
 940              * - remove req from list_in */
 941             lttv_hooks_call(events_request->after_request, (gpointer)tsc);
 942             /* - remove req from list_in */
 943             /* Destroy the request */
 944             remove = TRUE;
 945             free_data = TRUE;
 946           }
 947
 948           /* Go to next */
 949           if(remove)
 950           {
 951             GSList *remove_iter = iter;
 952
 953             iter = g_slist_next(iter);
 954             if(free_data) g_free(remove_iter->data);
 955             list_in = g_slist_remove_link(list_in, remove_iter);
 956           } else { // not remove
 957             iter = g_slist_next(iter);
 958           }
 959         }
 960       }
 961     }
 962
 963     if(gtk_events_pending()) break;
 964   }
 965
 966   /* B. When interrupted between chunks */
 967
 968   {
 969     GSList *iter = list_in;
 970
 971     /* 1. for each request in list_in */
 972     while(iter != NULL) {
 973
 974       gboolean remove = FALSE;
 975       gboolean free_data = FALSE;
 976       EventsRequest *events_request = (EventsRequest *)iter->data;
 977
 978       /* 1.1. Use current postition as start position */
 979       if(events_request->start_position != NULL)
 980         lttv_traceset_context_position_destroy(events_request->start_position);
 981       events_request->start_position = ltt_traceset_context_position_new();
 982       lttv_traceset_context_position_save(tsc, events_request->start_position);
 983
 984       /* 1.2. Remove start time */
 985       events_request->start_time.tv_sec = G_MAXUINT;
 986       events_request->start_time.tv_nsec = G_MAXUINT;
 987
 988       /* 1.3. Move from list_in to list_out */
 989       remove = TRUE;
 990       free_data = FALSE;
 991       list_out = g_slist_append(list_out, events_request);
 992
 993       /* Go to next */
 994       if(remove)
 995       {
 996         GSList *remove_iter = iter;
 997
 998         iter = g_slist_next(iter);
 999         if(free_data) g_free(remove_iter->data);
1000         list_in = g_slist_remove_link(list_in, remove_iter);
1001       } else { // not remove
1002         iter = g_slist_next(iter);
1003       }
1004     }
1005
1006
1007   }
1008
1009 #if 0
1010   //set the cursor back to normal
1011   gdk_window_set_cursor(win, NULL);
1012 #endif //0
1013
1014   g_assert(g_slist_length(list_in) == 0);
1015
1016   if( g_slist_length(list_out) == 0 ) {
1017     /* Put tab's request pending flag back to normal */
1018     tab->events_request_pending = FALSE;
1019     g_critical("remove the idle fct");
1020     return FALSE; /* Remove the idle function */
1021   }
1022   g_critical("leave the idle fct");
1023   return TRUE; /* Leave the idle function */
1024 }
1025
1026 #undef list_out
1027
1028
1029 /* add_trace_into_traceset_selector, each instance of a viewer has an associated
1030  * selector (filter), when a trace is added into traceset, the selector should
1031  * reflect the change. The function is used to update the selector
1032  */
1033
1034 void add_trace_into_traceset_selector(GtkMultiVPaned * paned, LttTrace * t)
1035 {
1036   int j, k, m, nb_tracefile, nb_control, nb_per_cpu, nb_facility, nb_event;
1037   LttvTracesetSelector  * s;
1038   LttvTraceSelector     * trace;
1039   LttvTracefileSelector * tracefile;
1040   LttvEventtypeSelector * eventtype;
1041   LttTracefile          * tf;
1042   GtkWidget             * w;
1043   LttFacility           * fac;
1044   LttEventType          * et;
1045
1046   w = gtk_multi_vpaned_get_first_widget(paned);
1047   while(w){
1048     s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
1049
1050     if(s){
1051       trace   = lttv_trace_selector_new(t);
1052       lttv_traceset_selector_trace_add(s, trace);
1053
1054       nb_facility = ltt_trace_facility_number(t);
1055       for(k=0;k<nb_facility;k++){
1056         fac = ltt_trace_facility_get(t,k);
1057         nb_event = (int) ltt_facility_eventtype_number(fac);
1058         for(m=0;m<nb_event;m++){
1059           et = ltt_facility_eventtype_get(fac,m);
1060           eventtype = lttv_eventtype_selector_new(et);
1061           lttv_trace_selector_eventtype_add(trace, eventtype);
1062         }
1063       }
1064
1065       nb_control = ltt_trace_control_tracefile_number(t);
1066       nb_per_cpu = ltt_trace_per_cpu_tracefile_number(t);
1067       nb_tracefile = nb_control + nb_per_cpu;
1068
1069       for(j = 0 ; j < nb_tracefile ; j++) {
1070         if(j < nb_control)
1071           tf = ltt_trace_control_tracefile_get(t, j);
1072         else
1073           tf = ltt_trace_per_cpu_tracefile_get(t, j - nb_control);
1074         tracefile = lttv_tracefile_selector_new(tf);
1075         lttv_trace_selector_tracefile_add(trace, tracefile);
1076         lttv_eventtype_selector_copy(trace, tracefile);
1077       }
1078     }else g_warning("Module does not support filtering\n");
1079
1080     w = gtk_multi_vpaned_get_next_widget(paned);
1081   }
1082 }
1083
1084
1085 static void lttvwindow_add_trace(Tab *tab, LttvTrace *trace_v)
1086 {
1087   LttvTraceset *traceset = tab->traceset_info->traceset;
1088   guint i;
1089
1090  //Verify if trace is already present.
1091   for(i=0; i<lttv_traceset_number(traceset); i++)
1092   {
1093     LttvTrace * trace = lttv_traceset_get(traceset, i);
1094     if(trace == trace_v)
1095       return;
1096   }
1097
1098   //Keep a reference to the traces so they are not freed.
1099   for(i=0; i<lttv_traceset_number(traceset); i++)
1100   {
1101     LttvTrace * trace = lttv_traceset_get(traceset, i);
1102     lttv_trace_ref(trace);
1103   }
1104
1105   //remove state update hooks
1106   lttv_state_remove_event_hooks(
1107      (LttvTracesetState*)tab->traceset_info->traceset_context);
1108
1109   lttv_context_fini(LTTV_TRACESET_CONTEXT(
1110           tab->traceset_info->traceset_context));
1111   g_object_unref(tab->traceset_info->traceset_context);
1112
1113   lttv_traceset_add(traceset, trace_v);
1114   lttv_trace_ref(trace_v);  /* local ref */
1115
1116   /* Create new context */
1117   tab->traceset_info->traceset_context =
1118                           g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
1119   lttv_context_init(
1120             LTTV_TRACESET_CONTEXT(tab->traceset_info->
1121                                       traceset_context),
1122             traceset);
1123
1124   /* Set the tab's time window and current time if currently 0, 0 */
1125   if(tab->time_window.start_time.tv_sec == 0 &&
1126                       tab->time_window.start_time.tv_nsec == 0)
1127     tab->time_window.start_time =
1128         LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->
1129                                time_span.start_time;
1130   if(tab->time_window.time_width.tv_sec == 0 &&
1131                       tab->time_window.time_width.tv_nsec == 0) {
1132     LttTime tmp_time;
1133
1134     if(DEFAULT_TIME_WIDTH_S <
1135             LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->
1136                            time_span.end_time.tv_sec)
1137       tmp_time.tv_sec = DEFAULT_TIME_WIDTH_S;
1138     else
1139       tmp_time.tv_sec =
1140               LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->
1141                            time_span.end_time.tv_sec;
1142     tmp_time.tv_nsec = 0;
1143     tab->time_window.time_width = tmp_time ;
1144   }
1145   if(tab->current_time.tv_sec == 0 &&  tab->current_time.tv_nsec == 0) {
1146     tab->current_time.tv_sec =
1147        LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->
1148                              time_span.start_time.tv_sec;
1149     tab->current_time.tv_nsec =
1150        LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->
1151                              time_span.start_time.tv_nsec;
1152   }
1153
1154
1155   //add state update hooks
1156   lttv_state_add_event_hooks(
1157   (LttvTracesetState*)tab->traceset_info->traceset_context);
1158   //Remove local reference to the traces.
1159   for(i=0; i<lttv_traceset_number(traceset); i++)
1160   {
1161     LttvTrace * trace = lttv_traceset_get(traceset, i);
1162     lttv_trace_unref(trace);
1163   }
1164
1165   add_trace_into_traceset_selector(tab->multi_vpaned, lttv_trace(trace_v));
1166 }
1167
1168 /* add_trace adds a trace into the current traceset. It first displays a
1169  * directory selection dialogue to let user choose a trace, then recreates
1170  * tracset_context, and redraws all the viewer of the current tab
1171  */
1172
1173 void add_trace(GtkWidget * widget, gpointer user_data)
1174 {
1175   LttTrace *trace;
1176   LttvTrace * trace_v;
1177   LttvTraceset * traceset;
1178   const char * dir;
1179   char abs_path[PATH_MAX];
1180   gint id;
1181   gint i;
1182   MainWindow * mw_data = get_window_data_struct(widget);
1183   GtkWidget * notebook = lookup_widget(widget, "MNotebook");
1184
1185   GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
1186                       gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
1187   Tab *tab;
1188
1189   if(!page) {
1190     tab = create_new_tab(widget, NULL);
1191   } else {
1192     tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
1193   }
1194
1195   GtkDirSelection * file_selector = (GtkDirSelection *)gtk_dir_selection_new("Select a trace");
1196   gtk_dir_selection_hide_fileop_buttons(file_selector);
1197
1198   if(remember_trace_dir[0] != '\0')
1199     gtk_dir_selection_set_filename(file_selector, remember_trace_dir);
1200
1201   id = gtk_dialog_run(GTK_DIALOG(file_selector));
1202   switch(id){
1203     case GTK_RESPONSE_ACCEPT:
1204     case GTK_RESPONSE_OK:
1205       dir = gtk_dir_selection_get_dir (file_selector);
1206       strncpy(remember_trace_dir, dir, PATH_MAX);
1207       if(!dir || strlen(dir) == 0){
1208         gtk_widget_destroy((GtkWidget*)file_selector);
1209         break;
1210       }
1211       get_absolute_pathname(dir, abs_path);
1212       trace_v = lttvwindowtraces_get_trace_by_name(abs_path);
1213       if(trace_v == NULL) {
1214         trace = ltt_trace_open(abs_path);
1215         if(trace == NULL) {
1216           g_warning("cannot open trace %s", abs_path);
1217         } else {
1218           trace_v = lttv_trace_new(trace);
1219           lttvwindowtraces_add_trace(trace_v);
1220           lttvwindow_add_trace(tab, trace_v);
1221         }
1222       } else {
1223         lttvwindow_add_trace(tab, trace_v);
1224       }
1225
1226       gtk_widget_destroy((GtkWidget*)file_selector);
1227
1228       //update current tab
1229       //update_traceset(mw_data);
1230
1231       /* Call the updatetraceset hooks */
1232
1233       traceset = tab->traceset_info->traceset;
1234       SetTraceset(tab, traceset);
1235       // in expose now call_pending_read_hooks(mw_data);
1236
1237       //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1238       break;
1239     case GTK_RESPONSE_REJECT:
1240     case GTK_RESPONSE_CANCEL:
1241     default:
1242       gtk_widget_destroy((GtkWidget*)file_selector);
1243       break;
1244   }
1245 }
1246
1247
1248 /* remove_trace_into_traceset_selector, each instance of a viewer has an associated
1249  * selector (filter), when a trace is remove from traceset, the selector should
1250  * reflect the change. The function is used to update the selector
1251  */
1252
1253 void remove_trace_from_traceset_selector(GtkMultiVPaned * paned, unsigned i)
1254 {
1255   LttvTracesetSelector * s;
1256   LttvTraceSelector * t;
1257   GtkWidget * w;
1258
1259   w = gtk_multi_vpaned_get_first_widget(paned);
1260   while(w){
1261     s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
1262     if(s){
1263       t = lttv_traceset_selector_trace_get(s,i);
1264       lttv_traceset_selector_trace_remove(s, i);
1265       lttv_trace_selector_destroy(t);
1266     }g_warning("Module dose not support filtering\n");
1267     w = gtk_multi_vpaned_get_next_widget(paned);
1268   }
1269 }
1270
1271
1272 /* remove_trace removes a trace from the current traceset if all viewers in
1273  * the current tab are not interested in the trace. It first displays a
1274  * dialogue, which shows all traces in the current traceset, to let user choose
1275  * a trace, then it checks if all viewers unselect the trace, if it is true,
1276  * it will remove the trace,  recreate the traceset_contex,
1277  * and redraws all the viewer of the current tab. If there is on trace in the
1278  * current traceset, it will delete all viewers of the current tab
1279  */
1280
1281 void remove_trace(GtkWidget * widget, gpointer user_data)
1282 {
1283   LttTrace *trace;
1284   LttvTrace * trace_v;
1285   LttvTraceset * traceset;
1286   gint i, j, nb_trace;
1287   char ** name, *remove_trace_name;
1288   MainWindow * mw_data = get_window_data_struct(widget);
1289   LttvTracesetSelector * s;
1290   LttvTraceSelector * t;
1291   GtkWidget * w;
1292   gboolean selected;
1293   GtkWidget * notebook = lookup_widget(widget, "MNotebook");
1294
1295   GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
1296                       gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
1297   Tab *tab;
1298
1299   if(!page) {
1300     return;
1301   } else {
1302     tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
1303   }
1304
1305   nb_trace =lttv_traceset_number(tab->traceset_info->traceset);
1306   name = g_new(char*,nb_trace);
1307   for(i = 0; i < nb_trace; i++){
1308     trace_v = lttv_traceset_get(tab->traceset_info->traceset, i);
1309     trace = lttv_trace(trace_v);
1310     name[i] = ltt_trace_name(trace);
1311   }
1312
1313   remove_trace_name = get_remove_trace(name, nb_trace);
1314
1315   if(remove_trace_name){
1316     for(i=0; i<nb_trace; i++){
1317       if(strcmp(remove_trace_name,name[i]) == 0){
1318               //unselect the trace from the current viewer
1319         w = gtk_multi_vpaned_get_widget(tab->multi_vpaned);
1320         if(w){
1321           s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
1322           if(s){
1323             t = lttv_traceset_selector_trace_get(s,i);
1324             lttv_trace_selector_set_selected(t, FALSE);
1325           }
1326
1327           //check if other viewers select the trace
1328           w = gtk_multi_vpaned_get_first_widget(tab->multi_vpaned);
1329           while(w){
1330             s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
1331             if(s){
1332               t = lttv_traceset_selector_trace_get(s,i);
1333               selected = lttv_trace_selector_get_selected(t);
1334               if(selected)break;
1335             }
1336             w = gtk_multi_vpaned_get_next_widget(tab->multi_vpaned);
1337           }
1338         }else selected = FALSE;
1339
1340         //if no viewer selects the trace, remove it
1341         if(!selected){
1342           remove_trace_from_traceset_selector(tab->multi_vpaned, i);
1343
1344           traceset = tab->traceset_info->traceset;
1345          //Keep a reference to the traces so they are not freed.
1346           for(j=0; j<lttv_traceset_number(traceset); j++)
1347           {
1348             LttvTrace * trace = lttv_traceset_get(traceset, j);
1349             lttv_trace_ref(trace);
1350           }
1351
1352           //remove state update hooks
1353           lttv_state_remove_event_hooks(
1354                (LttvTracesetState*)tab->traceset_info->traceset_context);
1355           lttv_context_fini(LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context));
1356           g_object_unref(tab->traceset_info->traceset_context);
1357
1358
1359           trace_v = lttv_traceset_get(traceset, i);
1360
1361           if(lttv_trace_get_ref_number(trace_v) <= 2) {
1362             /* ref 2 : traceset, local */
1363             lttvwindowtraces_remove_trace(trace_v);
1364             ltt_trace_close(lttv_trace(trace_v));
1365           }
1366
1367           lttv_traceset_remove(traceset, i);
1368           lttv_trace_unref(trace_v);  // Remove local reference
1369
1370           if(!lttv_trace_get_ref_number(trace_v))
1371              lttv_trace_destroy(trace_v);
1372
1373           tab->traceset_info->traceset_context =
1374             g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
1375           lttv_context_init(
1376                 LTTV_TRACESET_CONTEXT(tab->
1377                     traceset_info->traceset_context),traceset);
1378             //add state update hooks
1379           lttv_state_add_event_hooks(
1380             (LttvTracesetState*)tab->traceset_info->traceset_context);
1381
1382           //Remove local reference to the traces.
1383           for(j=0; j<lttv_traceset_number(traceset); j++)
1384           {
1385             LttvTrace * trace = lttv_traceset_get(traceset, j);
1386             lttv_trace_unref(trace);
1387           }
1388
1389
1390           //update current tab
1391           //update_traceset(mw_data);
1392           if(nb_trace > 1){
1393
1394             SetTraceset(mw_data, (gpointer)traceset);
1395             // in expose now call_pending_read_hooks(mw_data);
1396
1397             //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1398           }else{
1399             if(tab){
1400               while(tab->multi_vpaned->num_children){
1401                 gtk_multi_vpaned_widget_delete(tab->multi_vpaned);
1402               }
1403             }
1404           }
1405         }
1406         break;
1407       }
1408     }
1409   }
1410
1411   g_free(name);
1412 }
1413
1414
1415 /* Redraw all the viewers in the current tab */
1416 void redraw(GtkWidget *widget, gpointer user_data)
1417 {
1418   GtkWidget * notebook = lookup_widget(widget, "MNotebook");
1419   GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
1420                       gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
1421   Tab *tab;
1422   if(!page) {
1423     return;
1424   } else {
1425     tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
1426   }
1427
1428   LttvHooks * tmp;
1429   LttvAttributeValue value;
1430
1431   g_assert(lttv_iattribute_find_by_path(tab->attributes, "hooks/redraw", LTTV_POINTER, &value));
1432
1433   tmp = (LttvHooks*)*(value.v_pointer);
1434   if(tmp != NULL)
1435     lttv_hooks_call(tmp,NULL);
1436 }
1437
1438
1439 void continue_processing(GtkWidget *widget, gpointer user_data)
1440 {
1441   GtkWidget * notebook = lookup_widget(widget, "MNotebook");
1442   GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
1443                       gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
1444   Tab *tab;
1445   if(!page) {
1446     return;
1447   } else {
1448     tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
1449   }
1450
1451   LttvHooks * tmp;
1452   LttvAttributeValue value;
1453
1454   g_assert(lttv_iattribute_find_by_path(tab->attributes,
1455      "hooks/continue", LTTV_POINTER, &value));
1456
1457   tmp = (LttvHooks*)*(value.v_pointer);
1458   if(tmp != NULL)
1459     lttv_hooks_call(tmp,NULL);
1460 }
1461
1462 /* Stop the processing for the calling main window's current tab.
1463  * It removes every processing requests that are in its list. It does not call
1464  * the end request hooks, because the request is not finished.
1465  */
1466
1467 void stop_processing(GtkWidget *widget, gpointer user_data)
1468 {
1469   GtkWidget * notebook = lookup_widget(widget, "MNotebook");
1470   GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
1471                       gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
1472   Tab *tab;
1473   if(!page) {
1474     return;
1475   } else {
1476     tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
1477   }
1478   GSList *iter = tab->events_requests;
1479
1480   while(iter != NULL) {
1481     GSList *remove_iter = iter;
1482     iter = g_slist_next(iter);
1483
1484     g_free(remove_iter->data);
1485     tab->events_requests =
1486                        g_slist_remove_link(tab->events_requests, remove_iter);
1487   }
1488   tab->events_request_pending = FALSE;
1489   g_idle_remove_by_data(tab);
1490   g_assert(g_slist_length(tab->events_requests) == 0);
1491 }
1492
1493
1494 /* save will save the traceset to a file
1495  * Not implemented yet FIXME
1496  */
1497
1498 void save(GtkWidget * widget, gpointer user_data)
1499 {
1500   g_printf("Save\n");
1501 }
1502
1503 void save_as(GtkWidget * widget, gpointer user_data)
1504 {
1505   g_printf("Save as\n");
1506 }
1507
1508
1509 /* zoom will change the time_window of all the viewers of the
1510  * current tab, and redisplay them. The main functionality is to
1511  * determine the new time_window of the current tab
1512  */
1513
1514 void zoom(GtkWidget * widget, double size)
1515 {
1516   TimeInterval *time_span;
1517   TimeWindow new_time_window;
1518   LttTime    current_time, time_delta, time_s, time_e, time_tmp;
1519   MainWindow * mw_data = get_window_data_struct(widget);
1520   LttvTracesetContext *tsc;
1521   GtkWidget * notebook = lookup_widget(widget, "MNotebook");
1522
1523   GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
1524                       gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
1525   Tab *tab;
1526
1527   if(!page) {
1528     return;
1529   } else {
1530     tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
1531   }
1532
1533   if(size == 1) return;
1534
1535   tsc = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context);
1536   time_span = &tsc->time_span;
1537   new_time_window =  tab->time_window;
1538   current_time = tab->current_time;
1539
1540   time_delta = ltt_time_sub(time_span->end_time,time_span->start_time);
1541   if(size == 0){
1542     new_time_window.start_time = time_span->start_time;
1543     new_time_window.time_width = time_delta;
1544   }else{
1545     new_time_window.time_width = ltt_time_div(new_time_window.time_width, size);
1546     if(ltt_time_compare(new_time_window.time_width,time_delta) > 0)
1547     { /* Case where zoom out is bigger than trace length */
1548       new_time_window.start_time = time_span->start_time;
1549       new_time_window.time_width = time_delta;
1550     }
1551     else
1552     {
1553       /* Center the image on the current time */
1554       new_time_window.start_time =
1555         ltt_time_sub(current_time, ltt_time_div(new_time_window.time_width, 2.0));
1556       /* If on borders, don't fall off */
1557       if(ltt_time_compare(new_time_window.start_time, time_span->start_time) <0)
1558       {
1559         new_time_window.start_time = time_span->start_time;
1560       }
1561       else
1562       {
1563         if(ltt_time_compare(
1564            ltt_time_add(new_time_window.start_time, new_time_window.time_width),
1565            time_span->end_time) > 0)
1566         {
1567           new_time_window.start_time =
1568                   ltt_time_sub(time_span->end_time, new_time_window.time_width);
1569         }
1570       }
1571
1572     }
1573
1574
1575
1576     //time_tmp = ltt_time_div(new_time_window.time_width, 2);
1577     //if(ltt_time_compare(current_time, time_tmp) < 0){
1578     //  time_s = time_span->startTime;
1579     //} else {
1580     //  time_s = ltt_time_sub(current_time,time_tmp);
1581     //}
1582     //time_e = ltt_time_add(current_time,time_tmp);
1583     //if(ltt_time_compare(time_span->startTime, time_s) > 0){
1584     //  time_s = time_span->startTime;
1585     //}else if(ltt_time_compare(time_span->endTime, time_e) < 0){
1586     //  time_e = time_span->endTime;
1587     //  time_s = ltt_time_sub(time_e,new_time_window.time_width);
1588     //}
1589     //new_time_window.start_time = time_s;
1590   }
1591
1592   //lttvwindow_report_time_window(mw_data, &new_time_window);
1593   //call_pending_read_hooks(mw_data);
1594
1595   //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1596   set_time_window(tab, &new_time_window);
1597   // in expose now call_pending_read_hooks(mw_data);
1598   gtk_multi_vpaned_set_adjust(tab->multi_vpaned, &new_time_window, FALSE);
1599 }
1600
1601 void zoom_in(GtkWidget * widget, gpointer user_data)
1602 {
1603   zoom(widget, 2);
1604 }
1605
1606 void zoom_out(GtkWidget * widget, gpointer user_data)
1607 {
1608   zoom(widget, 0.5);
1609 }
1610
1611 void zoom_extended(GtkWidget * widget, gpointer user_data)
1612 {
1613   zoom(widget, 0);
1614 }
1615
1616 void go_to_time(GtkWidget * widget, gpointer user_data)
1617 {
1618   g_printf("Go to time\n");
1619 }
1620
1621 void show_time_frame(GtkWidget * widget, gpointer user_data)
1622 {
1623   g_printf("Show time frame\n");
1624 }
1625
1626
1627 /* callback function */
1628
1629 void
1630 on_empty_traceset_activate             (GtkMenuItem     *menuitem,
1631                                         gpointer         user_data)
1632 {
1633   create_new_window((GtkWidget*)menuitem, user_data, FALSE);
1634 }
1635
1636
1637 void
1638 on_clone_traceset_activate             (GtkMenuItem     *menuitem,
1639                                         gpointer         user_data)
1640 {
1641   create_new_window((GtkWidget*)menuitem, user_data, TRUE);
1642 }
1643
1644
1645 /* create_new_tab calls create_tab to construct a new tab in the main window
1646  */
1647
1648 Tab *create_new_tab(GtkWidget* widget, gpointer user_data){
1649   gchar label[PATH_MAX];
1650   MainWindow * mw_data = get_window_data_struct(widget);
1651
1652   GtkNotebook * notebook = (GtkNotebook *)lookup_widget(widget, "MNotebook");
1653   if(notebook == NULL){
1654     g_printf("Notebook does not exist\n");
1655     return NULL;
1656   }
1657   GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
1658                       gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
1659   Tab *copy_tab;
1660
1661   if(!page) {
1662     copy_tab = NULL;
1663   } else {
1664     copy_tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
1665   }
1666
1667   strcpy(label,"Page");
1668   if(get_label(mw_data, label,"Get the name of the tab","Please input tab's name"))
1669     return (create_tab (mw_data, copy_tab, notebook, label));
1670 }
1671
1672 void
1673 on_tab_activate                        (GtkMenuItem     *menuitem,
1674                                         gpointer         user_data)
1675 {
1676   create_new_tab((GtkWidget*)menuitem, user_data);
1677 }
1678
1679
1680 void
1681 on_open_activate                       (GtkMenuItem     *menuitem,
1682                                         gpointer         user_data)
1683 {
1684   open_traceset((GtkWidget*)menuitem, user_data);
1685 }
1686
1687
1688 void
1689 on_close_activate                      (GtkMenuItem     *menuitem,
1690                                         gpointer         user_data)
1691 {
1692   MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
1693   main_window_destructor(mw_data);
1694 }
1695
1696
1697 /* remove the current tab from the main window
1698  */
1699
1700 void
1701 on_close_tab_activate                  (GtkWidget       *widget,
1702                                         gpointer         user_data)
1703 {
1704   gint page_num;
1705   GtkWidget * notebook;
1706   GtkWidget * page;
1707   MainWindow * mw_data = get_window_data_struct(widget);
1708   notebook = lookup_widget(widget, "MNotebook");
1709   if(notebook == NULL){
1710     g_printf("Notebook does not exist\n");
1711     return;
1712   }
1713
1714   page_num = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
1715
1716   gtk_notebook_remove_page(GTK_NOTEBOOK(notebook), page_num);
1717
1718 }
1719
1720 void
1721 on_close_tab_X_clicked                 (GtkWidget       *widget,
1722                                         gpointer         user_data)
1723 {
1724   gint page_num;
1725   GtkWidget *notebook = lookup_widget(widget, "MNotebook");
1726   if(notebook == NULL){
1727     g_printf("Notebook does not exist\n");
1728     return;
1729   }
1730
1731   if((page_num = gtk_notebook_page_num(GTK_NOTEBOOK(notebook), widget)) != -1)
1732     gtk_notebook_remove_page(GTK_NOTEBOOK(notebook), page_num);
1733
1734 }
1735
1736
1737 void
1738 on_add_trace_activate                  (GtkMenuItem     *menuitem,
1739                                         gpointer         user_data)
1740 {
1741   add_trace((GtkWidget*)menuitem, user_data);
1742 }
1743
1744
1745 void
1746 on_remove_trace_activate               (GtkMenuItem     *menuitem,
1747                                         gpointer         user_data)
1748 {
1749   remove_trace((GtkWidget*)menuitem, user_data);
1750 }
1751
1752
1753 void
1754 on_save_activate                       (GtkMenuItem     *menuitem,
1755                                         gpointer         user_data)
1756 {
1757   save((GtkWidget*)menuitem, user_data);
1758 }
1759
1760
1761 void
1762 on_save_as_activate                    (GtkMenuItem     *menuitem,
1763                                         gpointer         user_data)
1764 {
1765   save_as((GtkWidget*)menuitem, user_data);
1766 }
1767
1768
1769 void
1770 on_quit_activate                       (GtkMenuItem     *menuitem,
1771                                         gpointer         user_data)
1772 {
1773   gtk_main_quit ();
1774 }
1775
1776
1777 void
1778 on_cut_activate                        (GtkMenuItem     *menuitem,
1779                                         gpointer         user_data)
1780 {
1781   g_printf("Cut\n");
1782 }
1783
1784
1785 void
1786 on_copy_activate                       (GtkMenuItem     *menuitem,
1787                                         gpointer         user_data)
1788 {
1789   g_printf("Copye\n");
1790 }
1791
1792
1793 void
1794 on_paste_activate                      (GtkMenuItem     *menuitem,
1795                                         gpointer         user_data)
1796 {
1797   g_printf("Paste\n");
1798 }
1799
1800
1801 void
1802 on_delete_activate                     (GtkMenuItem     *menuitem,
1803                                         gpointer         user_data)
1804 {
1805   g_printf("Delete\n");
1806 }
1807
1808
1809 void
1810 on_zoom_in_activate                    (GtkMenuItem     *menuitem,
1811                                         gpointer         user_data)
1812 {
1813    zoom_in((GtkWidget*)menuitem, user_data);
1814 }
1815
1816
1817 void
1818 on_zoom_out_activate                   (GtkMenuItem     *menuitem,
1819                                         gpointer         user_data)
1820 {
1821    zoom_out((GtkWidget*)menuitem, user_data);
1822 }
1823
1824
1825 void
1826 on_zoom_extended_activate              (GtkMenuItem     *menuitem,
1827                                         gpointer         user_data)
1828 {
1829    zoom_extended((GtkWidget*)menuitem, user_data);
1830 }
1831
1832
1833 void
1834 on_go_to_time_activate                 (GtkMenuItem     *menuitem,
1835                                         gpointer         user_data)
1836 {
1837    go_to_time((GtkWidget*)menuitem, user_data);
1838 }
1839
1840
1841 void
1842 on_show_time_frame_activate            (GtkMenuItem     *menuitem,
1843                                         gpointer         user_data)
1844 {
1845    show_time_frame((GtkWidget*)menuitem, user_data);
1846 }
1847
1848
1849 void
1850 on_move_viewer_up_activate             (GtkMenuItem     *menuitem,
1851                                         gpointer         user_data)
1852 {
1853   move_up_viewer((GtkWidget*)menuitem, user_data);
1854 }
1855
1856
1857 void
1858 on_move_viewer_down_activate           (GtkMenuItem     *menuitem,
1859                                         gpointer         user_data)
1860 {
1861   move_down_viewer((GtkWidget*)menuitem, user_data);
1862 }
1863
1864
1865 void
1866 on_remove_viewer_activate              (GtkMenuItem     *menuitem,
1867                                         gpointer         user_data)
1868 {
1869   delete_viewer((GtkWidget*)menuitem, user_data);
1870 }
1871
1872 void
1873 on_trace_filter_activate              (GtkMenuItem     *menuitem,
1874                                         gpointer         user_data)
1875 {
1876   MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
1877   LttvTracesetSelector * s;
1878   GtkWidget * w;
1879   GtkWidget * notebook = lookup_widget(GTK_WIDGET(menuitem), "MNotebook");
1880
1881   GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
1882                       gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
1883   Tab *tab;
1884
1885   if(!page) {
1886     return;
1887   } else {
1888     tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
1889   }
1890
1891   w = gtk_multi_vpaned_get_widget(tab->multi_vpaned);
1892
1893   s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
1894   if(!s){
1895     g_printf("There is no viewer yet\n");
1896     return;
1897   }
1898   if(get_filter_selection(s, "Configure trace and tracefile filter", "Select traces and tracefiles")){
1899     //FIXME report filter change
1900     //update_traceset(mw_data);
1901     //call_pending_read_hooks(mw_data);
1902     //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1903   }
1904 }
1905
1906 void
1907 on_trace_facility_activate              (GtkMenuItem     *menuitem,
1908                                         gpointer         user_data)
1909 {
1910   g_printf("Trace facility selector: %s\n");
1911 }
1912
1913
1914 /* Dispaly a file selection dialogue to let user select a module, then call
1915  * lttv_module_load(), finally insert tool button and menu entry in the main window
1916  * for the loaded  module
1917  */
1918
1919 void
1920 on_load_module_activate                (GtkMenuItem     *menuitem,
1921                                         gpointer         user_data)
1922 {
1923   char ** dir;
1924   gint id;
1925   char str[PATH_MAX], *str1;
1926   MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
1927   GtkFileSelection * file_selector = (GtkFileSelection *)gtk_file_selection_new("Select a module");
1928   if(remember_plugins_dir[0] != '\0')
1929     gtk_file_selection_set_filename(file_selector, remember_plugins_dir);
1930   gtk_file_selection_hide_fileop_buttons(file_selector);
1931
1932   str[0] = '\0';
1933   id = gtk_dialog_run(GTK_DIALOG(file_selector));
1934   switch(id){
1935     case GTK_RESPONSE_ACCEPT:
1936     case GTK_RESPONSE_OK:
1937       dir = gtk_file_selection_get_selections (file_selector);
1938       strncpy(str,dir[0],PATH_MAX);
1939       strncpy(remember_plugins_dir,dir[0],PATH_MAX);
1940       str1 = strrchr(str,'/');
1941       if(str1)str1++;
1942       else{
1943         str1 = strrchr(str,'\\');
1944         str1++;
1945       }
1946       lttv_module_require(str1, NULL);
1947       g_strfreev(dir);
1948     case GTK_RESPONSE_REJECT:
1949     case GTK_RESPONSE_CANCEL:
1950     default:
1951       gtk_widget_destroy((GtkWidget*)file_selector);
1952       break;
1953   }
1954   g_printf("Load module: %s\n", str);
1955 }
1956
1957
1958 /* Display all loaded modules, let user to select a module to unload
1959  * by calling lttv_module_unload
1960  */
1961
1962 void
1963 on_unload_module_activate              (GtkMenuItem     *menuitem,
1964                                         gpointer         user_data)
1965 {
1966   int i;
1967   GPtrArray *name;
1968   char *unload_module_name;
1969   guint nb;
1970   LttvLibrary *library;
1971   LttvLibraryInfo library_info;
1972   MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
1973
1974   name  = g_ptr_array_new();
1975   nb = lttv_library_number();
1976
1977   for(i=0;i<nb;i++){
1978     library = lttv_library_get(i);
1979     lttv_library_info(library, &library_info);
1980     if(library_info.load_count > 0) g_ptr_array_add(name, library_info.name);
1981   }
1982
1983   unload_module_name =get_unload_module((char **)(name->pdata), name->len);
1984
1985   if(unload_module_name){
1986     for(i=0;i<nb;i++){
1987       library = lttv_library_get(i);
1988       lttv_library_info(library, &library_info);
1989       if(strcmp(unload_module_name, library_info.name) == 0){
1990               lttv_library_unload(library);
1991         break;
1992       }
1993     }
1994   }
1995
1996   g_ptr_array_free(name, TRUE);
1997 }
1998
1999
2000 /* Display a directory dialogue to let user select a path for module searching
2001  */
2002
2003 void
2004 on_add_module_search_path_activate     (GtkMenuItem     *menuitem,
2005                                         gpointer         user_data)
2006 {
2007   GtkDirSelection * file_selector = (GtkDirSelection *)gtk_dir_selection_new("Select module path");
2008   const char * dir;
2009   gint id;
2010
2011   MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
2012   if(remember_plugins_dir[0] != '\0')
2013     gtk_dir_selection_set_filename(file_selector, remember_plugins_dir);
2014
2015   id = gtk_dialog_run(GTK_DIALOG(file_selector));
2016   switch(id){
2017     case GTK_RESPONSE_ACCEPT:
2018     case GTK_RESPONSE_OK:
2019       dir = gtk_dir_selection_get_dir (file_selector);
2020       strncpy(remember_plugins_dir,dir,PATH_MAX);
2021       strncat(remember_plugins_dir,"/",PATH_MAX);
2022       lttv_library_path_add(dir);
2023     case GTK_RESPONSE_REJECT:
2024     case GTK_RESPONSE_CANCEL:
2025     default:
2026       gtk_widget_destroy((GtkWidget*)file_selector);
2027       break;
2028   }
2029 }
2030
2031
2032 void
2033 on_color_activate                      (GtkMenuItem     *menuitem,
2034                                         gpointer         user_data)
2035 {
2036   g_printf("Color\n");
2037 }
2038
2039
2040 void
2041 on_filter_activate                     (GtkMenuItem     *menuitem,
2042                                         gpointer         user_data)
2043 {
2044   g_printf("Filter\n");
2045 }
2046
2047
2048 void
2049 on_save_configuration_activate         (GtkMenuItem     *menuitem,
2050                                         gpointer         user_data)
2051 {
2052   g_printf("Save configuration\n");
2053 }
2054
2055
2056 void
2057 on_content_activate                    (GtkMenuItem     *menuitem,
2058                                         gpointer         user_data)
2059 {
2060   g_printf("Content\n");
2061 }
2062
2063
2064 void
2065 on_about_activate                      (GtkMenuItem     *menuitem,
2066                                         gpointer         user_data)
2067 {
2068   g_printf("About...\n");
2069 }
2070
2071
2072 void
2073 on_button_new_clicked                  (GtkButton       *button,
2074                                         gpointer         user_data)
2075 {
2076   create_new_window((GtkWidget*)button, user_data, TRUE);
2077 }
2078
2079 void
2080 on_button_new_tab_clicked              (GtkButton       *button,
2081                                         gpointer         user_data)
2082 {
2083   create_new_tab((GtkWidget*)button, user_data);
2084 }
2085
2086 void
2087 on_button_open_clicked                 (GtkButton       *button,
2088                                         gpointer         user_data)
2089 {
2090   open_traceset((GtkWidget*)button, user_data);
2091 }
2092
2093
2094 void
2095 on_button_add_trace_clicked            (GtkButton       *button,
2096                                         gpointer         user_data)
2097 {
2098   add_trace((GtkWidget*)button, user_data);
2099 }
2100
2101
2102 void
2103 on_button_remove_trace_clicked         (GtkButton       *button,
2104                                         gpointer         user_data)
2105 {
2106   remove_trace((GtkWidget*)button, user_data);
2107 }
2108
2109 void
2110 on_button_redraw_clicked               (GtkButton       *button,
2111                                         gpointer         user_data)
2112 {
2113   redraw((GtkWidget*)button, user_data);
2114 }
2115
2116 void
2117 on_button_continue_processing_clicked  (GtkButton       *button,
2118                                         gpointer         user_data)
2119 {
2120   continue_processing((GtkWidget*)button, user_data);
2121 }
2122
2123 void
2124 on_button_stop_processing_clicked      (GtkButton       *button,
2125                                         gpointer         user_data)
2126 {
2127   stop_processing((GtkWidget*)button, user_data);
2128 }
2129
2130
2131
2132 void
2133 on_button_save_clicked                 (GtkButton       *button,
2134                                         gpointer         user_data)
2135 {
2136   save((GtkWidget*)button, user_data);
2137 }
2138
2139
2140 void
2141 on_button_save_as_clicked              (GtkButton       *button,
2142                                         gpointer         user_data)
2143 {
2144   save_as((GtkWidget*)button, user_data);
2145 }
2146
2147
2148 void
2149 on_button_zoom_in_clicked              (GtkButton       *button,
2150                                         gpointer         user_data)
2151 {
2152    zoom_in((GtkWidget*)button, user_data);
2153 }
2154
2155
2156 void
2157 on_button_zoom_out_clicked             (GtkButton       *button,
2158                                         gpointer         user_data)
2159 {
2160    zoom_out((GtkWidget*)button, user_data);
2161 }
2162
2163
2164 void
2165 on_button_zoom_extended_clicked        (GtkButton       *button,
2166                                         gpointer         user_data)
2167 {
2168    zoom_extended((GtkWidget*)button, user_data);
2169 }
2170
2171
2172 void
2173 on_button_go_to_time_clicked           (GtkButton       *button,
2174                                         gpointer         user_data)
2175 {
2176    go_to_time((GtkWidget*)button, user_data);
2177 }
2178
2179
2180 void
2181 on_button_show_time_frame_clicked      (GtkButton       *button,
2182                                         gpointer         user_data)
2183 {
2184    show_time_frame((GtkWidget*)button, user_data);
2185 }
2186
2187
2188 void
2189 on_button_move_up_clicked              (GtkButton       *button,
2190                                         gpointer         user_data)
2191 {
2192   move_up_viewer((GtkWidget*)button, user_data);
2193 }
2194
2195
2196 void
2197 on_button_move_down_clicked            (GtkButton       *button,
2198                                         gpointer         user_data)
2199 {
2200   move_down_viewer((GtkWidget*)button, user_data);
2201 }
2202
2203
2204 void
2205 on_button_delete_viewer_clicked        (GtkButton       *button,
2206                                         gpointer         user_data)
2207 {
2208   delete_viewer((GtkWidget*)button, user_data);
2209 }
2210
2211 void
2212 on_MWindow_destroy                     (GtkWidget       *widget,
2213                                         gpointer         user_data)
2214 {
2215   MainWindow *main_window = get_window_data_struct(widget);
2216   LttvIAttribute *attributes = main_window->attributes;
2217   LttvAttributeValue value;
2218
2219   //This is unnecessary, since widgets will be destroyed
2220   //by the main window widget anyway.
2221   //remove_all_menu_toolbar_constructors(main_window, NULL);
2222
2223   g_assert(lttv_iattribute_find_by_path(attributes,
2224            "viewers/menu", LTTV_POINTER, &value));
2225   lttv_menus_destroy((LttvMenus*)*(value.v_pointer));
2226
2227   g_assert(lttv_iattribute_find_by_path(attributes,
2228            "viewers/toolbar", LTTV_POINTER, &value));
2229   lttv_toolbars_destroy((LttvToolbars*)*(value.v_pointer));
2230
2231   g_object_unref(main_window->attributes);
2232   g_main_window_list = g_slist_remove(g_main_window_list, main_window);
2233
2234   g_printf("There are now : %d windows\n",g_slist_length(g_main_window_list));
2235   if(g_slist_length(g_main_window_list) == 0)
2236     gtk_main_quit ();
2237 }
2238
2239 gboolean
2240 on_MWindow_configure                   (GtkWidget         *widget,
2241                                         GdkEventConfigure *event,
2242                                         gpointer           user_data)
2243 {
2244   MainWindow * mw_data = get_window_data_struct((GtkWidget*)widget);
2245   float width = event->width;
2246   TimeWindow time_win;
2247   double ratio;
2248   TimeInterval *time_span;
2249   LttTime time;
2250
2251         // MD : removed time width modification upon resizing of the main window.
2252         // The viewers will redraw themselves completely, without time interval
2253         // modification.
2254 /*  while(tab){
2255     if(mw_data->window_width){
2256       time_span = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->Time_Span ;
2257       time_win = tab->time_window;
2258       ratio = width / mw_data->window_width;
2259       tab->time_window.time_width = ltt_time_mul(time_win.time_width,ratio);
2260       time = ltt_time_sub(time_span->endTime, time_win.start_time);
2261       if(ltt_time_compare(time, tab->time_window.time_width) < 0){
2262         tab->time_window.time_width = time;
2263       }
2264     }
2265     tab = tab->next;
2266   }
2267
2268   mw_data->window_width = (int)width;
2269         */
2270   return FALSE;
2271 }
2272
2273 /* Set current tab
2274  */
2275
2276 void
2277 on_MNotebook_switch_page               (GtkNotebook     *notebook,
2278                                         GtkNotebookPage *page,
2279                                         guint            page_num,
2280                                         gpointer         user_data)
2281 {
2282
2283 }
2284
2285
2286 /* callback function to check or uncheck the check box (filter)
2287  */
2288
2289 void checkbox_changed(GtkTreeView *treeview,
2290                       GtkTreePath *arg1,
2291                       GtkTreeViewColumn *arg2,
2292                       gpointer user_data)
2293 {
2294   GtkTreeStore * store = (GtkTreeStore *)gtk_tree_view_get_model (treeview);
2295   GtkTreeIter iter;
2296   gboolean value;
2297
2298   if (gtk_tree_model_get_iter ((GtkTreeModel *)store, &iter, arg1)){
2299     gtk_tree_model_get ((GtkTreeModel *)store, &iter, CHECKBOX_COLUMN, &value, -1);
2300     value = value? FALSE : TRUE;
2301     gtk_tree_store_set (GTK_TREE_STORE (store), &iter, CHECKBOX_COLUMN, value, -1);
2302   }
2303
2304 }
2305
2306
2307 /* According to user's selection, update selector(filter)
2308  */
2309
2310 void update_filter(LttvTracesetSelector *s,  GtkTreeStore *store )
2311 {
2312   GtkTreeIter iter, child_iter, child_iter1, child_iter2;
2313   int i, j, k, nb_eventtype;
2314   LttvTraceSelector     * trace;
2315   LttvTracefileSelector * tracefile;
2316   LttvEventtypeSelector * eventtype;
2317   gboolean value, value1, value2;
2318
2319   if(gtk_tree_model_get_iter_first((GtkTreeModel*)store, &iter)){
2320     i = 0;
2321     do{
2322       trace = lttv_traceset_selector_trace_get(s, i);
2323       nb_eventtype = lttv_trace_selector_eventtype_number(trace);
2324       gtk_tree_model_get ((GtkTreeModel*)store, &iter, CHECKBOX_COLUMN, &value,-1);
2325       if(value){
2326         j = 0;
2327         if(gtk_tree_model_iter_children ((GtkTreeModel*)store, &child_iter, &iter)){
2328           do{
2329             if(j<1){//eventtype selector for trace
2330               gtk_tree_model_get ((GtkTreeModel*)store, &child_iter, CHECKBOX_COLUMN, &value2,-1);
2331               if(value2){
2332                 k=0;
2333                 if(gtk_tree_model_iter_children ((GtkTreeModel*)store, &child_iter1, &child_iter)){
2334                   do{
2335                     eventtype = lttv_trace_selector_eventtype_get(trace,k);
2336                     gtk_tree_model_get ((GtkTreeModel*)store, &child_iter1, CHECKBOX_COLUMN, &value2,-1);
2337                     lttv_eventtype_selector_set_selected(eventtype,value2);
2338                     k++;
2339                   }while(gtk_tree_model_iter_next((GtkTreeModel*)store, &child_iter1));
2340                 }
2341               }
2342             }else{ //tracefile selector
2343               tracefile = lttv_trace_selector_tracefile_get(trace, j - 1);
2344               gtk_tree_model_get ((GtkTreeModel*)store, &child_iter, CHECKBOX_COLUMN, &value1,-1);
2345               lttv_tracefile_selector_set_selected(tracefile,value1);
2346               if(value1){
2347                 gtk_tree_model_iter_children((GtkTreeModel*)store, &child_iter1, &child_iter); //eventtype selector
2348                 gtk_tree_model_get ((GtkTreeModel*)store, &child_iter1, CHECKBOX_COLUMN, &value2,-1);
2349                 if(value2){
2350                   k = 0;
2351                   if(gtk_tree_model_iter_children ((GtkTreeModel*)store, &child_iter2, &child_iter1)){
2352                     do{//eventtype selector for tracefile
2353                       eventtype = lttv_tracefile_selector_eventtype_get(tracefile,k);
2354                       gtk_tree_model_get ((GtkTreeModel*)store, &child_iter2, CHECKBOX_COLUMN, &value2,-1);
2355                       lttv_eventtype_selector_set_selected(eventtype,value2);
2356                       k++;
2357                     }while(gtk_tree_model_iter_next((GtkTreeModel*)store, &child_iter2));
2358                   }
2359                 }
2360               }
2361             }
2362             j++;
2363           }while(gtk_tree_model_iter_next((GtkTreeModel*)store, &child_iter));
2364         }
2365       }
2366       lttv_trace_selector_set_selected(trace,value);
2367       i++;
2368     }while(gtk_tree_model_iter_next((GtkTreeModel*)store, &iter));
2369   }
2370 }
2371
2372
2373 /* Display a dialogue showing all eventtypes and traces, let user to select the interested
2374  * eventtypes, tracefiles and traces (filter)
2375  */
2376
2377 gboolean get_filter_selection(LttvTracesetSelector *s,char *title, char * column_title)
2378 {
2379   GtkWidget         * dialogue;
2380   GtkTreeStore      * store;
2381   GtkWidget         * tree;
2382   GtkWidget         * scroll_win;
2383   GtkCellRenderer   * renderer;
2384   GtkTreeViewColumn * column;
2385   GtkTreeIter         iter, child_iter, child_iter1, child_iter2;
2386   int i, j, k, id, nb_trace, nb_tracefile, nb_eventtype;
2387   LttvTraceSelector     * trace;
2388   LttvTracefileSelector * tracefile;
2389   LttvEventtypeSelector * eventtype;
2390   char * name;
2391   gboolean checked;
2392
2393   dialogue = gtk_dialog_new_with_buttons(title,
2394                                          NULL,
2395                                          GTK_DIALOG_MODAL,
2396                                          GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
2397                                          GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
2398                                          NULL);
2399   gtk_window_set_default_size((GtkWindow*)dialogue, 300, 500);
2400
2401   store = gtk_tree_store_new (TOTAL_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_STRING);
2402   tree  = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
2403   g_object_unref (G_OBJECT (store));
2404   g_signal_connect (G_OBJECT (tree), "row-activated",
2405                     G_CALLBACK (checkbox_changed),
2406                     NULL);
2407
2408
2409   renderer = gtk_cell_renderer_toggle_new ();
2410   gtk_cell_renderer_toggle_set_radio((GtkCellRendererToggle *)renderer, FALSE);
2411
2412   g_object_set (G_OBJECT (renderer),"activatable", TRUE, NULL);
2413
2414   column   = gtk_tree_view_column_new_with_attributes ("Checkbox",
2415                                                        renderer,
2416                                                        "active", CHECKBOX_COLUMN,
2417                                                        NULL);
2418   gtk_tree_view_column_set_alignment (column, 0.5);
2419   gtk_tree_view_column_set_fixed_width (column, 20);
2420   gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
2421
2422   renderer = gtk_cell_renderer_text_new ();
2423   column   = gtk_tree_view_column_new_with_attributes (column_title,
2424                                                        renderer,
2425                                                        "text", NAME_COLUMN,
2426                                                        NULL);
2427   gtk_tree_view_column_set_alignment (column, 0.0);
2428   gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
2429   gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (tree), FALSE);
2430
2431   scroll_win = gtk_scrolled_window_new (NULL, NULL);
2432   gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win),
2433                                  GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
2434   gtk_container_add (GTK_CONTAINER (scroll_win), tree);
2435
2436   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), scroll_win,TRUE, TRUE,0);
2437
2438   gtk_widget_show(scroll_win);
2439   gtk_widget_show(tree);
2440
2441   nb_trace = lttv_traceset_selector_trace_number(s);
2442   for(i=0;i<nb_trace;i++){
2443     trace = lttv_traceset_selector_trace_get(s, i);
2444     name  = lttv_trace_selector_get_name(trace);
2445     gtk_tree_store_append (store, &iter, NULL);
2446     checked = lttv_trace_selector_get_selected(trace);
2447     gtk_tree_store_set (store, &iter,
2448                         CHECKBOX_COLUMN,checked,
2449                         NAME_COLUMN,name,
2450                         -1);
2451
2452     gtk_tree_store_append (store, &child_iter, &iter);
2453     gtk_tree_store_set (store, &child_iter,
2454                         CHECKBOX_COLUMN, checked,
2455                         NAME_COLUMN,"eventtype",
2456                         -1);
2457
2458     nb_eventtype = lttv_trace_selector_eventtype_number(trace);
2459     for(j=0;j<nb_eventtype;j++){
2460       eventtype = lttv_trace_selector_eventtype_get(trace,j);
2461       name      = lttv_eventtype_selector_get_name(eventtype);
2462       checked   = lttv_eventtype_selector_get_selected(eventtype);
2463       gtk_tree_store_append (store, &child_iter1, &child_iter);
2464       gtk_tree_store_set (store, &child_iter1,
2465                           CHECKBOX_COLUMN, checked,
2466                           NAME_COLUMN,name,
2467                           -1);
2468     }
2469
2470     nb_tracefile = lttv_trace_selector_tracefile_number(trace);
2471     for(j=0;j<nb_tracefile;j++){
2472       tracefile = lttv_trace_selector_tracefile_get(trace, j);
2473       name      = lttv_tracefile_selector_get_name(tracefile);
2474       gtk_tree_store_append (store, &child_iter, &iter);
2475       checked = lttv_tracefile_selector_get_selected(tracefile);
2476       gtk_tree_store_set (store, &child_iter,
2477                           CHECKBOX_COLUMN, checked,
2478                           NAME_COLUMN,name,
2479                           -1);
2480
2481       gtk_tree_store_append (store, &child_iter1, &child_iter);
2482       gtk_tree_store_set (store, &child_iter1,
2483                           CHECKBOX_COLUMN, checked,
2484                           NAME_COLUMN,"eventtype",
2485                           -1);
2486
2487       for(k=0;k<nb_eventtype;k++){
2488         eventtype = lttv_tracefile_selector_eventtype_get(tracefile,k);
2489         name      = lttv_eventtype_selector_get_name(eventtype);
2490         checked   = lttv_eventtype_selector_get_selected(eventtype);
2491         gtk_tree_store_append (store, &child_iter2, &child_iter1);
2492         gtk_tree_store_set (store, &child_iter2,
2493                             CHECKBOX_COLUMN, checked,
2494                             NAME_COLUMN,name,
2495                             -1);
2496       }
2497     }
2498   }
2499
2500   id = gtk_dialog_run(GTK_DIALOG(dialogue));
2501   switch(id){
2502     case GTK_RESPONSE_ACCEPT:
2503     case GTK_RESPONSE_OK:
2504       update_filter(s, store);
2505       gtk_widget_destroy(dialogue);
2506       return TRUE;
2507     case GTK_RESPONSE_REJECT:
2508     case GTK_RESPONSE_CANCEL:
2509     default:
2510       gtk_widget_destroy(dialogue);
2511       break;
2512   }
2513   return FALSE;
2514 }
2515
2516
2517 /* Select a trace which will be removed from traceset
2518  */
2519
2520 char * get_remove_trace(char ** all_trace_name, int nb_trace)
2521 {
2522   return get_selection(all_trace_name, nb_trace,
2523                        "Select a trace", "Trace pathname");
2524 }
2525
2526
2527 /* Select a module which will be unloaded
2528  */
2529
2530 char * get_unload_module(char ** loaded_module_name, int nb_module)
2531 {
2532   return get_selection(loaded_module_name, nb_module,
2533                        "Select an unload module", "Module pathname");
2534 }
2535
2536
2537 /* Display a dialogue which shows all selectable items, let user to
2538  * select one of them
2539  */
2540
2541 char * get_selection(char ** loaded_module_name, int nb_module,
2542                      char *title, char * column_title)
2543 {
2544   GtkWidget         * dialogue;
2545   GtkWidget         * scroll_win;
2546   GtkWidget         * tree;
2547   GtkListStore      * store;
2548   GtkTreeViewColumn * column;
2549   GtkCellRenderer   * renderer;
2550   GtkTreeSelection  * select;
2551   GtkTreeIter         iter;
2552   gint                id, i;
2553   char              * unload_module_name = NULL;
2554
2555   dialogue = gtk_dialog_new_with_buttons(title,
2556                                          NULL,
2557                                          GTK_DIALOG_MODAL,
2558                                          GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
2559                                          GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
2560                                          NULL);
2561   gtk_window_set_default_size((GtkWindow*)dialogue, 500, 200);
2562
2563   scroll_win = gtk_scrolled_window_new (NULL, NULL);
2564   gtk_widget_show ( scroll_win);
2565   gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win),
2566                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2567
2568   store = gtk_list_store_new (N_COLUMNS,G_TYPE_STRING);
2569   tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL (store));
2570   gtk_widget_show ( tree);
2571   g_object_unref (G_OBJECT (store));
2572
2573   renderer = gtk_cell_renderer_text_new ();
2574   column   = gtk_tree_view_column_new_with_attributes (column_title,
2575                                                      renderer,
2576                                                      "text", MODULE_COLUMN,
2577                                                      NULL);
2578   gtk_tree_view_column_set_alignment (column, 0.5);
2579   gtk_tree_view_column_set_fixed_width (column, 150);
2580   gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
2581
2582   select = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
2583   gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
2584
2585   gtk_container_add (GTK_CONTAINER (scroll_win), tree);
2586
2587   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), scroll_win,TRUE, TRUE,0);
2588
2589   for(i=0;i<nb_module;i++){
2590     gtk_list_store_append (store, &iter);
2591     gtk_list_store_set (store, &iter, MODULE_COLUMN,loaded_module_name[i],-1);
2592   }
2593
2594   id = gtk_dialog_run(GTK_DIALOG(dialogue));
2595   switch(id){
2596     case GTK_RESPONSE_ACCEPT:
2597     case GTK_RESPONSE_OK:
2598       if (gtk_tree_selection_get_selected (select, (GtkTreeModel**)&store, &iter)){
2599           gtk_tree_model_get ((GtkTreeModel*)store, &iter, MODULE_COLUMN, &unload_module_name, -1);
2600       }
2601     case GTK_RESPONSE_REJECT:
2602     case GTK_RESPONSE_CANCEL:
2603     default:
2604       gtk_widget_destroy(dialogue);
2605       break;
2606   }
2607
2608   return unload_module_name;
2609 }
2610
2611
2612 /* Insert all menu entry and tool buttons into this main window
2613  * for modules.
2614  *
2615  */
2616
2617 void add_all_menu_toolbar_constructors(MainWindow * mw, gpointer user_data)
2618 {
2619   int i;
2620   GdkPixbuf *pixbuf;
2621   lttvwindow_viewer_constructor constructor;
2622   LttvMenus * global_menu, * instance_menu;
2623   LttvToolbars * global_toolbar, * instance_toolbar;
2624   LttvMenuClosure *menu_item;
2625   LttvToolbarClosure *toolbar_item;
2626   LttvAttributeValue value;
2627   LttvIAttribute *global_attributes = LTTV_IATTRIBUTE(lttv_global_attributes());
2628   LttvIAttribute *attributes = mw->attributes;
2629   GtkWidget * tool_menu_title_menu, *new_widget, *pixmap;
2630
2631   g_assert(lttv_iattribute_find_by_path(global_attributes,
2632            "viewers/menu", LTTV_POINTER, &value));
2633   if(*(value.v_pointer) == NULL)
2634     *(value.v_pointer) = lttv_menus_new();
2635   global_menu = (LttvMenus*)*(value.v_pointer);
2636
2637   g_assert(lttv_iattribute_find_by_path(attributes,
2638            "viewers/menu", LTTV_POINTER, &value));
2639   if(*(value.v_pointer) == NULL)
2640     *(value.v_pointer) = lttv_menus_new();
2641   instance_menu = (LttvMenus*)*(value.v_pointer);
2642
2643
2644
2645   g_assert(lttv_iattribute_find_by_path(global_attributes,
2646            "viewers/toolbar", LTTV_POINTER, &value));
2647   if(*(value.v_pointer) == NULL)
2648     *(value.v_pointer) = lttv_toolbars_new();
2649   global_toolbar = (LttvToolbars*)*(value.v_pointer);
2650
2651   g_assert(lttv_iattribute_find_by_path(attributes,
2652            "viewers/toolbar", LTTV_POINTER, &value));
2653   if(*(value.v_pointer) == NULL)
2654     *(value.v_pointer) = lttv_toolbars_new();
2655   instance_toolbar = (LttvToolbars*)*(value.v_pointer);
2656
2657   /* Add missing menu entries to window instance */
2658   for(i=0;i<global_menu->len;i++) {
2659     menu_item = &g_array_index(global_menu, LttvMenuClosure, i);
2660
2661     //add menu_item to window instance;
2662     constructor = menu_item->con;
2663     tool_menu_title_menu = lookup_widget(mw->mwindow,"ToolMenuTitle_menu");
2664     new_widget =
2665       gtk_menu_item_new_with_mnemonic (menu_item->menu_text);
2666     gtk_container_add (GTK_CONTAINER (tool_menu_title_menu),
2667         new_widget);
2668     g_signal_connect ((gpointer) new_widget, "activate",
2669         G_CALLBACK (insert_viewer_wrap),
2670         constructor);
2671     gtk_widget_show (new_widget);
2672     lttv_menus_add(instance_menu, menu_item->con,
2673         menu_item->menu_path,
2674         menu_item->menu_text,
2675         new_widget);
2676
2677   }
2678
2679   /* Add missing toolbar entries to window instance */
2680   for(i=0;i<global_toolbar->len;i++) {
2681     toolbar_item = &g_array_index(global_toolbar, LttvToolbarClosure, i);
2682
2683     //add toolbar_item to window instance;
2684     constructor = toolbar_item->con;
2685     tool_menu_title_menu = lookup_widget(mw->mwindow,"MToolbar1");
2686     pixbuf = gdk_pixbuf_new_from_xpm_data((const char**)toolbar_item->pixmap);
2687     pixmap = gtk_image_new_from_pixbuf(pixbuf);
2688     new_widget =
2689        gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu),
2690           GTK_TOOLBAR_CHILD_BUTTON,
2691           NULL,
2692           "",
2693           toolbar_item->tooltip, NULL,
2694           pixmap, NULL, NULL);
2695     gtk_label_set_use_underline(
2696         GTK_LABEL (((GtkToolbarChild*) (
2697                          g_list_last (GTK_TOOLBAR
2698                             (tool_menu_title_menu)->children)->data))->label),
2699         TRUE);
2700     gtk_container_set_border_width (GTK_CONTAINER (new_widget), 1);
2701     g_signal_connect ((gpointer) new_widget,
2702         "clicked",
2703         G_CALLBACK (insert_viewer_wrap),
2704         constructor);
2705     gtk_widget_show (new_widget);
2706
2707     lttv_toolbars_add(instance_toolbar, toolbar_item->con,
2708                       toolbar_item->tooltip,
2709                       toolbar_item->pixmap,
2710                       new_widget);
2711
2712   }
2713
2714 }
2715
2716
2717 /* Create a main window
2718  */
2719
2720 void construct_main_window(MainWindow * parent)
2721 {
2722   g_debug("construct_main_window()");
2723   GtkWidget  * new_window; /* New generated main window */
2724   MainWindow * new_m_window;/* New main window structure */
2725   GtkNotebook * notebook;
2726   LttvIAttribute *attributes =
2727           LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
2728   LttvAttributeValue value;
2729   Tab *new_tab;
2730
2731   new_m_window = g_new(MainWindow, 1);
2732
2733   // Add the object's information to the module's array
2734   g_main_window_list = g_slist_append(g_main_window_list, new_m_window);
2735
2736
2737   new_window  = create_MWindow();
2738   gtk_widget_show (new_window);
2739
2740   new_m_window->mwindow = new_window;
2741   new_m_window->attributes = attributes;
2742
2743   g_assert(lttv_iattribute_find_by_path(attributes,
2744            "viewers/menu", LTTV_POINTER, &value));
2745   *(value.v_pointer) = lttv_menus_new();
2746
2747   g_assert(lttv_iattribute_find_by_path(attributes,
2748            "viewers/toolbar", LTTV_POINTER, &value));
2749   *(value.v_pointer) = lttv_toolbars_new();
2750
2751   add_all_menu_toolbar_constructors(new_m_window, NULL);
2752
2753   g_object_set_data_full(G_OBJECT(new_window),
2754                          "main_window_data",
2755                          (gpointer)new_m_window,
2756                          (GDestroyNotify)g_free);
2757   //create a default tab
2758   notebook = (GtkNotebook *)lookup_widget(new_m_window->mwindow, "MNotebook");
2759   if(notebook == NULL){
2760     g_printf("Notebook does not exist\n");
2761     return;
2762   }
2763   gtk_notebook_popup_enable (GTK_NOTEBOOK(notebook));
2764   //for now there is no name field in LttvTraceset structure
2765   //Use "Traceset" as the label for the default tab
2766   if(parent) {
2767     GtkWidget * parent_notebook = lookup_widget(parent->mwindow, "MNotebook");
2768     GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(parent_notebook),
2769                  gtk_notebook_get_current_page(GTK_NOTEBOOK(parent_notebook)));
2770     Tab *parent_tab;
2771
2772     if(!page) {
2773       parent_tab = NULL;
2774     } else {
2775       parent_tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
2776     }
2777     new_tab = create_tab(new_m_window, parent_tab, notebook, "Traceset");
2778   } else {
2779     new_tab = create_tab(new_m_window, NULL, notebook, "Traceset");
2780     if(g_init_trace != NULL){
2781       lttvwindow_add_trace(new_tab,
2782                            g_init_trace);
2783     }
2784   }
2785
2786   g_printf("There are now : %d windows\n",g_slist_length(g_main_window_list));
2787 }
2788
2789
2790 /* Free the memory occupied by a tab structure
2791  * destroy the tab
2792  */
2793
2794 void tab_destructor(Tab * tab_instance)
2795 {
2796   int i, nb, ref_count;
2797   LttvTrace * trace;
2798
2799   if(tab_instance->attributes)
2800     g_object_unref(tab_instance->attributes);
2801
2802   if(tab_instance->interrupted_state)
2803     g_object_unref(tab_instance->interrupted_state);
2804
2805
2806   if(tab_instance->traceset_info->traceset_context != NULL){
2807     //remove state update hooks
2808     lttv_state_remove_event_hooks(
2809          (LttvTracesetState*)tab_instance->traceset_info->
2810                               traceset_context);
2811     lttv_context_fini(LTTV_TRACESET_CONTEXT(tab_instance->traceset_info->
2812                                             traceset_context));
2813     g_object_unref(tab_instance->traceset_info->traceset_context);
2814   }
2815   if(tab_instance->traceset_info->traceset != NULL) {
2816     nb = lttv_traceset_number(tab_instance->traceset_info->traceset);
2817     for(i = 0 ; i < nb ; i++) {
2818       trace = lttv_traceset_get(tab_instance->traceset_info->traceset, i);
2819       ref_count = lttv_trace_get_ref_number(trace);
2820       if(ref_count <= 1){
2821               ltt_trace_close(lttv_trace(trace));
2822       }
2823     }
2824   }
2825   lttv_traceset_destroy(tab_instance->traceset_info->traceset);
2826   /* Remove the idle events requests processing function of the tab */
2827   g_idle_remove_by_data(tab_instance);
2828
2829   g_slist_free(tab_instance->events_requests);
2830   g_free(tab_instance->traceset_info);
2831   g_free(tab_instance);
2832 }
2833
2834
2835 /* Create a tab and insert it into the current main window
2836  */
2837
2838 Tab* create_tab(MainWindow * mw, Tab *copy_tab,
2839                   GtkNotebook * notebook, char * label)
2840 {
2841   GList * list;
2842   Tab * tab;
2843   LttTime tmp_time;
2844
2845   //create a new tab data structure
2846   tab = g_new(Tab,1);
2847
2848   //construct and initialize the traceset_info
2849   tab->traceset_info = g_new(TracesetInfo,1);
2850
2851   if(copy_tab) {
2852     tab->traceset_info->traceset =
2853       lttv_traceset_copy(copy_tab->traceset_info->traceset);
2854   } else {
2855     tab->traceset_info->traceset = lttv_traceset_new();
2856   }
2857
2858 //FIXME : this is g_debug level
2859   lttv_attribute_write_xml(
2860       lttv_traceset_attribute(tab->traceset_info->traceset),
2861       stdout,
2862       0, 4);
2863   fflush(stdout);
2864
2865
2866   //FIXME copy not implemented in lower level
2867   tab->traceset_info->traceset_context =
2868     g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
2869   g_assert(tab->traceset_info->traceset_context != NULL);
2870   lttv_context_init(
2871             LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context),
2872                                   tab->traceset_info->traceset);
2873   //add state update hooks
2874   lttv_state_add_event_hooks(
2875        (LttvTracesetState*)tab->traceset_info->traceset_context);
2876
2877   //determine the current_time and time_window of the tab
2878   if(copy_tab != NULL){
2879     tab->time_window      = copy_tab->time_window;
2880     tab->current_time     = copy_tab->current_time;
2881   }else{
2882     tab->time_window.start_time =
2883             LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->
2884                              time_span.start_time;
2885     if(DEFAULT_TIME_WIDTH_S <
2886               LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->
2887                              time_span.end_time.tv_sec)
2888       tmp_time.tv_sec = DEFAULT_TIME_WIDTH_S;
2889     else
2890       tmp_time.tv_sec =
2891               LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->
2892                              time_span.end_time.tv_sec;
2893     tmp_time.tv_nsec = 0;
2894     tab->time_window.time_width = tmp_time ;
2895     tab->current_time.tv_sec =
2896        LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->
2897                              time_span.start_time.tv_sec;
2898     tab->current_time.tv_nsec =
2899        LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->
2900                              time_span.start_time.tv_nsec;
2901   }
2902   tab->attributes = LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
2903   tab->interrupted_state = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
2904   tab->multi_vpaned = (GtkMultiVPaned*)gtk_multi_vpaned_new();
2905   gtk_widget_show((GtkWidget*)tab->multi_vpaned);
2906   tab->mw   = mw;
2907
2908   /*{
2909     // Display a label with a X
2910     GtkWidget *w_hbox = gtk_hbox_new(FALSE, 4);
2911     GtkWidget *w_label = gtk_label_new (label);
2912     GtkWidget *pixmap = create_pixmap(GTK_WIDGET(notebook), "close.png");
2913     GtkWidget *w_button = gtk_button_new ();
2914     gtk_container_add(GTK_CONTAINER(w_button), pixmap);
2915     //GtkWidget *w_button = gtk_button_new_with_label("x");
2916
2917     gtk_button_set_relief(GTK_BUTTON(w_button), GTK_RELIEF_NONE);
2918
2919     gtk_box_pack_start(GTK_BOX(w_hbox), w_label, TRUE, TRUE, 0);
2920     gtk_box_pack_end(GTK_BOX(w_hbox), w_button, FALSE,
2921                        FALSE, 0);
2922
2923     g_signal_connect_swapped (w_button, "clicked",
2924                       G_CALLBACK (on_close_tab_X_clicked),
2925                       tab->multi_vpaned);
2926
2927     gtk_widget_set_state(w_button, GTK_STATE_ACTIVE);
2928
2929     gtk_widget_show (w_label);
2930     gtk_widget_show (pixmap);
2931     gtk_widget_show (w_button);
2932     gtk_widget_show (w_hbox);
2933
2934     tab->label = w_hbox;
2935   }*/
2936
2937
2938   tab->label = gtk_label_new (label);
2939   gtk_widget_show (tab->label);
2940
2941
2942   /* Start with empty events requests list */
2943   tab->events_requests = NULL;
2944   tab->events_request_pending = FALSE;
2945
2946   g_object_set_data_full(
2947            G_OBJECT(tab->multi_vpaned),
2948            "Tab_Info",
2949                  tab,
2950                  (GDestroyNotify)tab_destructor);
2951
2952  //insert tab into notebook
2953   gtk_notebook_append_page(notebook,
2954                           (GtkWidget*)tab->multi_vpaned,
2955                           tab->label);
2956   list = gtk_container_get_children(GTK_CONTAINER(notebook));
2957   gtk_notebook_set_current_page(notebook,g_list_length(list)-1);
2958   // always show : not if(g_list_length(list)>1)
2959   gtk_notebook_set_show_tabs(notebook, TRUE);
2960
2961   return tab;
2962 }
2963
2964 /*
2965  * execute_events_requests
2966  *
2967  * Idle function that executes the pending requests for a tab.
2968  *
2969  * @return return value : TRUE : keep the idle function, FALSE : remove it.
2970  */
2971 gboolean execute_events_requests(Tab *tab)
2972 {
2973   return ( lttvwindow_process_pending_requests(tab) );
2974 }
2975