ltt/branches/poly/lttv/modules/gui/mainWin/src/callbacks.c

   1 #ifdef HAVE_CONFIG_H
   2 #  include <config.h>
   3 #endif
   4
   5 #include <gtk/gtk.h>
   6 #include <gmodule.h>
   7
   8 #include "callbacks.h"
   9 #include "interface.h"
  10 #include "support.h"
  11 #include <lttv/mainWindow.h>
  12 #include <lttv/menu.h>
  13 #include <lttv/toolbar.h>
  14 #include <lttv/gtkTraceSet.h>
  15 #include <lttv/module.h>
  16 #include <lttv/gtkdirsel.h>
  17 #include <lttv/iattribute.h>
  18 #include <lttv/lttvfilter.h>
  19 #include <ltt/trace.h>
  20
  21 #define PATH_LENGTH          256
  22 #define DEFAULT_TIME_WIDTH_S   1
  23
  24 extern LttvTrace *g_init_trace ;
  25
  26
  27 /** Array containing instanced objects. */
  28 extern GSList * g_main_window_list;
  29
  30 static int g_win_count = 0;
  31
  32 MainWindow * get_window_data_struct(GtkWidget * widget);
  33 char * get_unload_module(char ** loaded_module_name, int nb_module);
  34 char * get_remove_trace(char ** all_trace_name, int nb_trace);
  35 char * get_selection(char ** all_name, int nb, char *title, char * column_title);
  36 gboolean get_filter_selection(LttvTracesetSelector *s, char *title, char * column_title);
  37 void * create_tab(MainWindow * parent, MainWindow * current_window,
  38                   GtkNotebook * notebook, char * label);
  39
  40 void insert_viewer(GtkWidget* widget, view_constructor constructor);
  41 void update_filter(LttvTracesetSelector *s,  GtkTreeStore *store );
  42
  43 void checkbox_changed(GtkTreeView *treeview,
  44                       GtkTreePath *arg1,
  45                       GtkTreeViewColumn *arg2,
  46                       gpointer user_data);
  47 void remove_trace_from_traceset_selector(GtkMultiVPaned * paned, unsigned i);
  48 void add_trace_into_traceset_selector(GtkMultiVPaned * paned, LttTrace * trace);
  49
  50 LttvTracesetSelector * construct_traceset_selector(LttvTraceset * traceset);
  51
  52 void redraw_viewer(MainWindow * mw_data, TimeWindow * time_window);
  53 unsigned get_max_event_number(MainWindow * mw_data);
  54
  55 enum {
  56   CHECKBOX_COLUMN,
  57   NAME_COLUMN,
  58   TOTAL_COLUMNS
  59 };
  60
  61 enum
  62 {
  63   MODULE_COLUMN,
  64   N_COLUMNS
  65 };
  66
  67
  68 LttvTracesetSelector * construct_traceset_selector(LttvTraceset * traceset)
  69 {
  70   LttvTracesetSelector  * s;
  71   LttvTraceSelector     * trace;
  72   LttvTracefileSelector * tracefile;
  73   int i, j, nb_trace, nb_tracefile, nb_control, nb_per_cpu;
  74   LttvTrace * trace_v;
  75   LttTrace  * t;
  76   LttTracefile *tf;
  77
  78   s = lttv_traceset_selector_new(lttv_traceset_name(traceset));
  79   nb_trace = lttv_traceset_number(traceset);
  80   for(i=0;i<nb_trace;i++){
  81     trace_v = lttv_traceset_get(traceset, i);
  82     t       = lttv_trace(trace_v);
  83     trace   = lttv_trace_selector_new(t);
  84     lttv_traceset_selector_add(s, trace);
  85     nb_control = ltt_trace_control_tracefile_number(t);
  86     nb_per_cpu = ltt_trace_per_cpu_tracefile_number(t);
  87     nb_tracefile = nb_control + nb_per_cpu;
  88
  89     for(j = 0 ; j < nb_tracefile ; j++) {
  90       if(j < nb_control)
  91         tf = ltt_trace_control_tracefile_get(t, j);
  92       else
  93         tf = ltt_trace_per_cpu_tracefile_get(t, j - nb_control);
  94       tracefile = lttv_tracefile_selector_new(tf);
  95       lttv_trace_selector_add(trace, tracefile);
  96     }
  97   }
  98   return s;
  99 }
 100
 101 void
 102 insert_viewer_wrap(GtkWidget *menuitem, gpointer user_data)
 103 {
 104   guint val = 20;
 105
 106   insert_viewer((GtkWidget*)menuitem, (view_constructor)user_data);
 107   //  selected_hook(&val);
 108 }
 109
 110
 111 /* internal functions */
 112 void insert_viewer(GtkWidget* widget, view_constructor constructor)
 113 {
 114   GtkMultiVPaned * multi_vpaned;
 115   MainWindow * mw_data;
 116   GtkWidget * viewer;
 117   LttvTracesetSelector  * s;
 118   TimeInterval * time_interval;
 119   TimeWindow  time_window;
 120
 121   mw_data = get_window_data_struct(widget);
 122   if(!mw_data->current_tab) return;
 123   multi_vpaned = mw_data->current_tab->multi_vpaned;
 124
 125   s = construct_traceset_selector(mw_data->current_tab->traceset_info->traceset);
 126   viewer = (GtkWidget*)constructor(mw_data, s, "Traceset_Selector");
 127   if(viewer)
 128   {
 129     gtk_multi_vpaned_widget_add(multi_vpaned, viewer);
 130     // Added by MD
 131     //    g_object_unref(G_OBJECT(viewer));
 132
 133     time_window = mw_data->current_tab->time_window;
 134     time_interval = (TimeInterval*)g_object_get_data(G_OBJECT(viewer), TRACESET_TIME_SPAN);
 135     if(time_interval){
 136       time_window.start_time = time_interval->startTime;
 137       time_window.time_width = ltt_time_sub(time_interval->endTime,time_interval->startTime);
 138     }
 139
 140     redraw_viewer(mw_data,&time_window);
 141     set_current_time(mw_data,&(mw_data->current_tab->current_time));
 142   }
 143 }
 144
 145 void get_label_string (GtkWidget * text, gchar * label)
 146 {
 147   GtkEntry * entry = (GtkEntry*)text;
 148   if(strlen(gtk_entry_get_text(entry))!=0)
 149     strcpy(label,gtk_entry_get_text(entry));
 150 }
 151
 152 void get_label(MainWindow * mw, gchar * str, gchar* dialogue_title, gchar * label_str)
 153 {
 154   GtkWidget * dialogue;
 155   GtkWidget * text;
 156   GtkWidget * label;
 157   gint id;
 158
 159   dialogue = gtk_dialog_new_with_buttons(dialogue_title,NULL,
 160                                          GTK_DIALOG_MODAL,
 161                                          GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
 162                                          GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
 163                                          NULL);
 164
 165   label = gtk_label_new(label_str);
 166   gtk_widget_show(label);
 167
 168   text = gtk_entry_new();
 169   gtk_widget_show(text);
 170
 171   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), label,TRUE, TRUE,0);
 172   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), text,FALSE, FALSE,0);
 173
 174   id = gtk_dialog_run(GTK_DIALOG(dialogue));
 175   switch(id){
 176     case GTK_RESPONSE_ACCEPT:
 177       get_label_string(text,str);
 178       gtk_widget_destroy(dialogue);
 179       break;
 180     case GTK_RESPONSE_REJECT:
 181     default:
 182       gtk_widget_destroy(dialogue);
 183       break;
 184   }
 185 }
 186
 187 MainWindow * get_window_data_struct(GtkWidget * widget)
 188 {
 189   GtkWidget * mw;
 190   MainWindow * mw_data;
 191
 192   mw = lookup_widget(widget, "MWindow");
 193   if(mw == NULL){
 194     g_printf("Main window does not exist\n");
 195     return;
 196   }
 197
 198   mw_data = (MainWindow *) g_object_get_data(G_OBJECT(mw),"mainWindow");
 199   if(mw_data == NULL){
 200     g_printf("Main window data does not exist\n");
 201     return;
 202   }
 203   return mw_data;
 204 }
 205
 206 void create_new_window(GtkWidget* widget, gpointer user_data, gboolean clone)
 207 {
 208   MainWindow * parent = get_window_data_struct(widget);
 209
 210   if(clone){
 211     g_printf("Clone : use the same traceset\n");
 212     construct_main_window(parent, NULL);
 213   }else{
 214     g_printf("Empty : traceset is set to NULL\n");
 215     construct_main_window(NULL, parent->win_creation_data);
 216   }
 217 }
 218
 219 void move_up_viewer(GtkWidget * widget, gpointer user_data)
 220 {
 221   MainWindow * mw = get_window_data_struct(widget);
 222   if(!mw->current_tab) return;
 223   gtk_multi_vpaned_widget_move_up(mw->current_tab->multi_vpaned);
 224 }
 225
 226 void move_down_viewer(GtkWidget * widget, gpointer user_data)
 227 {
 228   MainWindow * mw = get_window_data_struct(widget);
 229   if(!mw->current_tab) return;
 230   gtk_multi_vpaned_widget_move_down(mw->current_tab->multi_vpaned);
 231 }
 232
 233 void delete_viewer(GtkWidget * widget, gpointer user_data)
 234 {
 235   MainWindow * mw = get_window_data_struct(widget);
 236   if(!mw->current_tab) return;
 237   gtk_multi_vpaned_widget_delete(mw->current_tab->multi_vpaned);
 238 }
 239
 240 void open_traceset(GtkWidget * widget, gpointer user_data)
 241 {
 242   char ** dir;
 243   gint id;
 244   LttvTraceset * traceset;
 245   MainWindow * mw_data = get_window_data_struct(widget);
 246   GtkFileSelection * file_selector =
 247     (GtkFileSelection *)gtk_file_selection_new("Select a traceset");
 248
 249   gtk_file_selection_hide_fileop_buttons(file_selector);
 250
 251   id = gtk_dialog_run(GTK_DIALOG(file_selector));
 252   switch(id){
 253     case GTK_RESPONSE_ACCEPT:
 254     case GTK_RESPONSE_OK:
 255       dir = gtk_file_selection_get_selections (file_selector);
 256       traceset = lttv_traceset_load(dir[0]);
 257       g_printf("Open a trace set %s\n", dir[0]);
 258       //Not finished yet
 259       g_strfreev(dir);
 260     case GTK_RESPONSE_REJECT:
 261     case GTK_RESPONSE_CANCEL:
 262     default:
 263       gtk_widget_destroy((GtkWidget*)file_selector);
 264       break;
 265   }
 266
 267 }
 268
 269 unsigned get_max_event_number(MainWindow * mw_data)
 270 {
 271   unsigned nb = 0, *size;
 272   GtkWidget * w;
 273
 274   w = gtk_multi_vpaned_get_first_widget(mw_data->current_tab->multi_vpaned);
 275   while(w){
 276     size = (unsigned*)g_object_get_data(G_OBJECT(w), MAX_NUMBER_EVENT);
 277     if(size == NULL){
 278       nb = G_MAXULONG;
 279       break;
 280     }else{
 281       if(nb < *size)
 282         nb = *size;
 283     }
 284     w = gtk_multi_vpaned_get_next_widget(mw_data->current_tab->multi_vpaned);
 285   }
 286   return nb;
 287 }
 288
 289 void redraw_viewer(MainWindow * mw_data, TimeWindow * time_window)
 290 {
 291   unsigned max_nb_events;
 292   GdkWindow * win;
 293   GdkCursor * new;
 294   GtkWidget* widget;
 295
 296   new = gdk_cursor_new(GDK_X_CURSOR);
 297   widget = lookup_widget(mw_data->mwindow, "MToolbar2");
 298   win = gtk_widget_get_parent_window(widget);
 299   gdk_window_set_cursor(win, new);
 300   gdk_cursor_unref(new);
 301   gdk_window_stick(win);
 302   gdk_window_unstick(win);
 303
 304   //update time window of each viewer, let viewer insert hooks needed by process_traceset
 305   set_time_window(mw_data, time_window);
 306
 307   max_nb_events = get_max_event_number(mw_data);
 308
 309   process_traceset_api(mw_data, time_window->start_time,
 310                        ltt_time_add(time_window->start_time,time_window->time_width),
 311                        max_nb_events);
 312
 313   //call hooks to show each viewer and let them remove hooks
 314   show_viewer(mw_data);
 315
 316   gdk_window_set_cursor(win, NULL);
 317 }
 318
 319 void add_trace_into_traceset_selector(GtkMultiVPaned * paned, LttTrace * t)
 320 {
 321   int j, nb_tracefile, nb_control, nb_per_cpu;
 322   LttvTracesetSelector  * s;
 323   LttvTraceSelector     * trace;
 324   LttvTracefileSelector * tracefile;
 325   LttTracefile          * tf;
 326   GtkWidget             * w;
 327
 328   w = gtk_multi_vpaned_get_first_widget(paned);
 329   while(w){
 330     s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
 331
 332     trace   = lttv_trace_selector_new(t);
 333     lttv_traceset_selector_add(s, trace);
 334     nb_control = ltt_trace_control_tracefile_number(t);
 335     nb_per_cpu = ltt_trace_per_cpu_tracefile_number(t);
 336     nb_tracefile = nb_control + nb_per_cpu;
 337
 338     for(j = 0 ; j < nb_tracefile ; j++) {
 339       if(j < nb_control)
 340         tf = ltt_trace_control_tracefile_get(t, j);
 341       else
 342         tf = ltt_trace_per_cpu_tracefile_get(t, j - nb_control);
 343       tracefile = lttv_tracefile_selector_new(tf);
 344       lttv_trace_selector_add(trace, tracefile);
 345     }
 346
 347     w = gtk_multi_vpaned_get_next_widget(paned);
 348   }
 349 }
 350
 351 void add_trace(GtkWidget * widget, gpointer user_data)
 352 {
 353   LttTrace *trace;
 354   LttvTrace * trace_v;
 355   LttvTraceset * traceset;
 356   char * dir;
 357   gint id;
 358   MainWindow * mw_data = get_window_data_struct(widget);
 359   GtkDirSelection * file_selector = (GtkDirSelection *)gtk_dir_selection_new("Select a trace");
 360   gtk_dir_selection_hide_fileop_buttons(file_selector);
 361
 362   id = gtk_dialog_run(GTK_DIALOG(file_selector));
 363   switch(id){
 364     case GTK_RESPONSE_ACCEPT:
 365     case GTK_RESPONSE_OK:
 366       dir = gtk_dir_selection_get_dir (file_selector);
 367       trace = ltt_trace_open(dir);
 368       if(trace == NULL) g_critical("cannot open trace %s", dir);
 369       trace_v = lttv_trace_new(trace);
 370       traceset = mw_data->current_tab->traceset_info->traceset;
 371       if(mw_data->current_tab->traceset_info->traceset_context != NULL){
 372         lttv_context_fini(LTTV_TRACESET_CONTEXT(mw_data->current_tab->
 373                                                 traceset_info->traceset_context));
 374         g_object_unref(mw_data->current_tab->traceset_info->traceset_context);
 375       }
 376       lttv_traceset_add(traceset, trace_v);
 377       mw_data->current_tab->traceset_info->traceset_context =
 378         g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
 379       lttv_context_init(
 380         LTTV_TRACESET_CONTEXT(mw_data->current_tab->traceset_info->
 381                               traceset_context),traceset);
 382       add_trace_into_traceset_selector(mw_data->current_tab->multi_vpaned, trace);
 383
 384       gtk_widget_destroy((GtkWidget*)file_selector);
 385
 386       //update current tab
 387       update_traceset(mw_data);
 388       redraw_viewer(mw_data, &(mw_data->current_tab->time_window));
 389       set_current_time(mw_data,&(mw_data->current_tab->current_time));
 390       break;
 391     case GTK_RESPONSE_REJECT:
 392     case GTK_RESPONSE_CANCEL:
 393     default:
 394       gtk_widget_destroy((GtkWidget*)file_selector);
 395       break;
 396   }
 397 }
 398
 399 void remove_trace_from_traceset_selector(GtkMultiVPaned * paned, unsigned i)
 400 {
 401   LttvTracesetSelector * s;
 402   LttvTraceSelector * t;
 403   GtkWidget * w;
 404
 405   w = gtk_multi_vpaned_get_first_widget(paned);
 406   while(w){
 407     s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
 408     t = lttv_traceset_selector_get(s,i);
 409     lttv_traceset_selector_remove(s, i);
 410     lttv_trace_selector_destroy(t);
 411     w = gtk_multi_vpaned_get_next_widget(paned);
 412   }
 413 }
 414
 415 void remove_trace(GtkWidget * widget, gpointer user_data)
 416 {
 417   LttTrace *trace;
 418   LttvTrace * trace_v;
 419   LttvTraceset * traceset;
 420   gint i, nb_trace;
 421   char ** name, *remove_trace_name;
 422   MainWindow * mw_data = get_window_data_struct(widget);
 423   LttvTracesetSelector * s;
 424   LttvTraceSelector * t;
 425   GtkWidget * w;
 426   gboolean selected;
 427
 428   nb_trace =lttv_traceset_number(mw_data->current_tab->traceset_info->traceset);
 429   name = g_new(char*,nb_trace);
 430   for(i = 0; i < nb_trace; i++){
 431     trace_v = lttv_traceset_get(mw_data->current_tab->
 432                                 traceset_info->traceset, i);
 433     trace = lttv_trace(trace_v);
 434     name[i] = ltt_trace_name(trace);
 435   }
 436
 437   remove_trace_name = get_remove_trace(name, nb_trace);
 438
 439   if(remove_trace_name){
 440     for(i=0; i<nb_trace; i++){
 441       if(strcmp(remove_trace_name,name[i]) == 0){
 442         //unselect the trace from the current viewer
 443         w = gtk_multi_vpaned_get_widget(mw_data->current_tab->multi_vpaned);
 444         s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
 445         t = lttv_traceset_selector_get(s,i);
 446         lttv_trace_selector_set_selected(t, FALSE);
 447
 448         //check if other viewers select the trace
 449         w = gtk_multi_vpaned_get_first_widget(mw_data->current_tab->multi_vpaned);
 450         while(w){
 451           s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
 452           t = lttv_traceset_selector_get(s,i);
 453           selected = lttv_trace_selector_get_selected(t);
 454           if(selected)break;
 455           w = gtk_multi_vpaned_get_next_widget(mw_data->current_tab->multi_vpaned);
 456         }
 457
 458         //if no viewer selects the trace, remove it
 459         if(!selected){
 460           remove_trace_from_traceset_selector(mw_data->current_tab->multi_vpaned, i);
 461
 462           traceset = mw_data->current_tab->traceset_info->traceset;
 463           trace_v = lttv_traceset_get(traceset, i);
 464           if(lttv_trace_get_ref_number(trace_v) <= 1)
 465             ltt_trace_close(lttv_trace(trace_v));
 466
 467           if(mw_data->current_tab->traceset_info->traceset_context != NULL){
 468             lttv_context_fini(LTTV_TRACESET_CONTEXT(mw_data->current_tab->
 469                                                     traceset_info->traceset_context));
 470             g_object_unref(mw_data->current_tab->traceset_info->traceset_context);
 471           }
 472           lttv_traceset_remove(traceset, i);
 473           lttv_trace_destroy(trace_v);
 474           mw_data->current_tab->traceset_info->traceset_context =
 475             g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
 476           lttv_context_init(
 477                             LTTV_TRACESET_CONTEXT(mw_data->current_tab->
 478                                       traceset_info->traceset_context),traceset);
 479           //update current tab
 480           update_traceset(mw_data);
 481           redraw_viewer(mw_data, &(mw_data->current_tab->time_window));
 482           set_current_time(mw_data,&(mw_data->current_tab->current_time));
 483         }
 484         break;
 485       }
 486     }
 487   }
 488
 489   g_free(name);
 490 }
 491
 492 void save(GtkWidget * widget, gpointer user_data)
 493 {
 494   g_printf("Save\n");
 495 }
 496
 497 void save_as(GtkWidget * widget, gpointer user_data)
 498 {
 499   g_printf("Save as\n");
 500 }
 501
 502 void zoom(GtkWidget * widget, double size)
 503 {
 504   TimeInterval *time_span;
 505   TimeWindow time_window;
 506   LttTime    current_time, time_delta, time_s, time_e, time_t;
 507   MainWindow * mw_data = get_window_data_struct(widget);
 508
 509   time_span = LTTV_TRACESET_CONTEXT(mw_data->current_tab->
 510                                     traceset_info->traceset_context)->Time_Span;
 511   time_window =  mw_data->current_tab->time_window;
 512   current_time = mw_data->current_tab->current_time;
 513
 514   time_delta = ltt_time_sub(time_span->endTime,time_span->startTime);
 515   if(size == 0){
 516     time_window.start_time = time_span->startTime;
 517     time_window.time_width = time_delta;
 518   }else{
 519     time_window.time_width = ltt_time_div(time_window.time_width, size);
 520     if(ltt_time_compare(time_window.time_width,time_delta) > 0)
 521       time_window.time_width = time_delta;
 522
 523     time_t = ltt_time_div(time_window.time_width, 2);
 524     if(ltt_time_compare(current_time, time_t) < 0){
 525       time_s = time_span->startTime;
 526     } else {
 527       time_s = ltt_time_sub(current_time,time_t);
 528     }
 529     time_e = ltt_time_add(current_time,time_t);
 530     if(ltt_time_compare(time_span->startTime, time_s) > 0){
 531       time_s = time_span->startTime;
 532     }else if(ltt_time_compare(time_span->endTime, time_e) < 0){
 533       time_e = time_span->endTime;
 534       time_s = ltt_time_sub(time_e,time_window.time_width);
 535     }
 536     time_window.start_time = time_s;
 537   }
 538   redraw_viewer(mw_data, &time_window);
 539   set_current_time(mw_data,&(mw_data->current_tab->current_time));
 540   gtk_multi_vpaned_set_adjust(mw_data->current_tab->multi_vpaned, FALSE);
 541 }
 542
 543 void zoom_in(GtkWidget * widget, gpointer user_data)
 544 {
 545   zoom(widget, 2);
 546 }
 547
 548 void zoom_out(GtkWidget * widget, gpointer user_data)
 549 {
 550   zoom(widget, 0.5);
 551 }
 552
 553 void zoom_extended(GtkWidget * widget, gpointer user_data)
 554 {
 555   zoom(widget, 0);
 556 }
 557
 558 void go_to_time(GtkWidget * widget, gpointer user_data)
 559 {
 560   g_printf("Go to time\n");
 561 }
 562
 563 void show_time_frame(GtkWidget * widget, gpointer user_data)
 564 {
 565   g_printf("Show time frame\n");
 566 }
 567
 568
 569 /* callback function */
 570
 571 void
 572 on_empty_traceset_activate             (GtkMenuItem     *menuitem,
 573                                         gpointer         user_data)
 574 {
 575   create_new_window((GtkWidget*)menuitem, user_data, FALSE);
 576 }
 577
 578
 579 void
 580 on_clone_traceset_activate             (GtkMenuItem     *menuitem,
 581                                         gpointer         user_data)
 582 {
 583   create_new_window((GtkWidget*)menuitem, user_data, TRUE);
 584 }
 585
 586
 587 void
 588 on_tab_activate                        (GtkMenuItem     *menuitem,
 589                                         gpointer         user_data)
 590 {
 591   gchar label[PATH_LENGTH];
 592   MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
 593   GtkNotebook * notebook = (GtkNotebook *)lookup_widget((GtkWidget*)menuitem, "MNotebook");
 594   if(notebook == NULL){
 595     g_printf("Notebook does not exist\n");
 596     return;
 597   }
 598
 599   strcpy(label,"Page");
 600   get_label(mw_data, label,"Get the name of the tab","Please input tab's name");
 601
 602   create_tab (mw_data, mw_data, notebook, label);
 603 }
 604
 605
 606 void
 607 on_open_activate                       (GtkMenuItem     *menuitem,
 608                                         gpointer         user_data)
 609 {
 610   open_traceset((GtkWidget*)menuitem, user_data);
 611 }
 612
 613
 614 void
 615 on_close_activate                      (GtkMenuItem     *menuitem,
 616                                         gpointer         user_data)
 617 {
 618   MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
 619   main_window_destructor(mw_data);
 620 }
 621
 622
 623 void
 624 on_close_tab_activate                  (GtkMenuItem     *menuitem,
 625                                         gpointer         user_data)
 626 {
 627   int count = 0;
 628   GtkWidget * notebook;
 629   Tab * tmp;
 630   MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
 631   notebook = lookup_widget((GtkWidget*)menuitem, "MNotebook");
 632   if(notebook == NULL){
 633     g_printf("Notebook does not exist\n");
 634     return;
 635   }
 636
 637   if(mw_data->tab == mw_data->current_tab){
 638     //    tmp = mw_data->current_tb;
 639     //    mw_data->tab = mw_data->current_tab->next;
 640     g_printf("The default TAB can not be deleted\n");
 641     return;
 642   }else{
 643     tmp = mw_data->tab;
 644     while(tmp != mw_data->current_tab){
 645       tmp = tmp->next;
 646       count++;
 647     }
 648   }
 649
 650   gtk_notebook_remove_page((GtkNotebook*)notebook, count);
 651 }
 652
 653
 654 void
 655 on_add_trace_activate                  (GtkMenuItem     *menuitem,
 656                                         gpointer         user_data)
 657 {
 658   add_trace((GtkWidget*)menuitem, user_data);
 659 }
 660
 661
 662 void
 663 on_remove_trace_activate               (GtkMenuItem     *menuitem,
 664                                         gpointer         user_data)
 665 {
 666   remove_trace((GtkWidget*)menuitem, user_data);
 667 }
 668
 669
 670 void
 671 on_save_activate                       (GtkMenuItem     *menuitem,
 672                                         gpointer         user_data)
 673 {
 674   save((GtkWidget*)menuitem, user_data);
 675 }
 676
 677
 678 void
 679 on_save_as_activate                    (GtkMenuItem     *menuitem,
 680                                         gpointer         user_data)
 681 {
 682   save_as((GtkWidget*)menuitem, user_data);
 683 }
 684
 685
 686 void
 687 on_quit_activate                       (GtkMenuItem     *menuitem,
 688                                         gpointer         user_data)
 689 {
 690   gtk_main_quit ();
 691 }
 692
 693
 694 void
 695 on_cut_activate                        (GtkMenuItem     *menuitem,
 696                                         gpointer         user_data)
 697 {
 698   g_printf("Cut\n");
 699 }
 700
 701
 702 void
 703 on_copy_activate                       (GtkMenuItem     *menuitem,
 704                                         gpointer         user_data)
 705 {
 706   g_printf("Copye\n");
 707 }
 708
 709
 710 void
 711 on_paste_activate                      (GtkMenuItem     *menuitem,
 712                                         gpointer         user_data)
 713 {
 714   g_printf("Paste\n");
 715 }
 716
 717
 718 void
 719 on_delete_activate                     (GtkMenuItem     *menuitem,
 720                                         gpointer         user_data)
 721 {
 722   g_printf("Delete\n");
 723 }
 724
 725
 726 void
 727 on_zoom_in_activate                    (GtkMenuItem     *menuitem,
 728                                         gpointer         user_data)
 729 {
 730    zoom_in((GtkWidget*)menuitem, user_data);
 731 }
 732
 733
 734 void
 735 on_zoom_out_activate                   (GtkMenuItem     *menuitem,
 736                                         gpointer         user_data)
 737 {
 738    zoom_out((GtkWidget*)menuitem, user_data);
 739 }
 740
 741
 742 void
 743 on_zoom_extended_activate              (GtkMenuItem     *menuitem,
 744                                         gpointer         user_data)
 745 {
 746    zoom_extended((GtkWidget*)menuitem, user_data);
 747 }
 748
 749
 750 void
 751 on_go_to_time_activate                 (GtkMenuItem     *menuitem,
 752                                         gpointer         user_data)
 753 {
 754    go_to_time((GtkWidget*)menuitem, user_data);
 755 }
 756
 757
 758 void
 759 on_show_time_frame_activate            (GtkMenuItem     *menuitem,
 760                                         gpointer         user_data)
 761 {
 762    show_time_frame((GtkWidget*)menuitem, user_data);
 763 }
 764
 765
 766 void
 767 on_move_viewer_up_activate             (GtkMenuItem     *menuitem,
 768                                         gpointer         user_data)
 769 {
 770   move_up_viewer((GtkWidget*)menuitem, user_data);
 771 }
 772
 773
 774 void
 775 on_move_viewer_down_activate           (GtkMenuItem     *menuitem,
 776                                         gpointer         user_data)
 777 {
 778   move_down_viewer((GtkWidget*)menuitem, user_data);
 779 }
 780
 781
 782 void
 783 on_remove_viewer_activate              (GtkMenuItem     *menuitem,
 784                                         gpointer         user_data)
 785 {
 786   delete_viewer((GtkWidget*)menuitem, user_data);
 787 }
 788
 789 void
 790 on_trace_filter_activate              (GtkMenuItem     *menuitem,
 791                                         gpointer         user_data)
 792 {
 793   MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
 794   LttvTracesetSelector * s;
 795   GtkWidget * w = gtk_multi_vpaned_get_widget(mw_data->current_tab->multi_vpaned);
 796
 797   s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
 798   if(!s){
 799     g_printf("There is no viewer yet\n");
 800     return;
 801   }
 802   if(get_filter_selection(s, "Configure trace and tracefile filter", "Select traces and tracefiles")){
 803     update_traceset(mw_data);
 804     redraw_viewer(mw_data, &(mw_data->current_tab->time_window));
 805     set_current_time(mw_data,&(mw_data->current_tab->current_time));
 806   }
 807 }
 808
 809 void
 810 on_trace_facility_activate              (GtkMenuItem     *menuitem,
 811                                         gpointer         user_data)
 812 {
 813   g_printf("Trace facility selector: %s\n");
 814 }
 815
 816 void
 817 on_load_module_activate                (GtkMenuItem     *menuitem,
 818                                         gpointer         user_data)
 819 {
 820   char ** dir;
 821   gint id;
 822   char str[PATH_LENGTH], *str1;
 823   MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
 824   GtkFileSelection * file_selector = (GtkFileSelection *)gtk_file_selection_new("Select a module");
 825   gtk_file_selection_hide_fileop_buttons(file_selector);
 826
 827   str[0] = '\0';
 828   id = gtk_dialog_run(GTK_DIALOG(file_selector));
 829   switch(id){
 830     case GTK_RESPONSE_ACCEPT:
 831     case GTK_RESPONSE_OK:
 832       dir = gtk_file_selection_get_selections (file_selector);
 833       sprintf(str,dir[0]);
 834       str1 = strrchr(str,'/');
 835       if(str1)str1++;
 836       else{
 837         str1 = strrchr(str,'\\');
 838         str1++;
 839       }
 840       if(mw_data->win_creation_data)
 841         lttv_module_load(str1, mw_data->win_creation_data->argc,mw_data->win_creation_data->argv);
 842       else
 843         lttv_module_load(str1, 0,NULL);
 844       g_slist_foreach(g_main_window_list, insert_menu_toolbar_item, NULL);
 845       g_strfreev(dir);
 846     case GTK_RESPONSE_REJECT:
 847     case GTK_RESPONSE_CANCEL:
 848     default:
 849       gtk_widget_destroy((GtkWidget*)file_selector);
 850       break;
 851   }
 852   g_printf("Load module: %s\n", str);
 853 }
 854
 855
 856 void
 857 on_unload_module_activate              (GtkMenuItem     *menuitem,
 858                                         gpointer         user_data)
 859 {
 860   int i;
 861   char **name, *unload_module_name;
 862   guint nb;
 863   LttvModule ** modules, *module;
 864   MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
 865
 866   modules = lttv_module_list(&nb);
 867   name  = g_new(char*, nb);
 868   for(i=0;i<nb;i++){
 869     module = modules[i];
 870     name[i] = lttv_module_name(module);
 871   }
 872
 873   unload_module_name =get_unload_module(name,nb);
 874
 875   if(unload_module_name){
 876     for(i=0;i<nb;i++){
 877       if(strcmp(unload_module_name, name[i]) == 0){
 878         lttv_module_unload(modules[i]);
 879         break;
 880       }
 881     }
 882   }
 883
 884   g_free(name);
 885 }
 886
 887
 888 void
 889 on_add_module_search_path_activate     (GtkMenuItem     *menuitem,
 890                                         gpointer         user_data)
 891 {
 892   GtkDirSelection * file_selector = (GtkDirSelection *)gtk_dir_selection_new("Select module path");
 893   char * dir;
 894   gint id;
 895
 896   MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
 897
 898   id = gtk_dialog_run(GTK_DIALOG(file_selector));
 899   switch(id){
 900     case GTK_RESPONSE_ACCEPT:
 901     case GTK_RESPONSE_OK:
 902       dir = gtk_dir_selection_get_dir (file_selector);
 903       lttv_module_path_add(dir);
 904     case GTK_RESPONSE_REJECT:
 905     case GTK_RESPONSE_CANCEL:
 906     default:
 907       gtk_widget_destroy((GtkWidget*)file_selector);
 908       break;
 909   }
 910 }
 911
 912
 913 void
 914 on_color_activate                      (GtkMenuItem     *menuitem,
 915                                         gpointer         user_data)
 916 {
 917   g_printf("Color\n");
 918 }
 919
 920
 921 void
 922 on_filter_activate                     (GtkMenuItem     *menuitem,
 923                                         gpointer         user_data)
 924 {
 925   g_printf("Filter\n");
 926 }
 927
 928
 929 void
 930 on_save_configuration_activate         (GtkMenuItem     *menuitem,
 931                                         gpointer         user_data)
 932 {
 933   g_printf("Save configuration\n");
 934 }
 935
 936
 937 void
 938 on_content_activate                    (GtkMenuItem     *menuitem,
 939                                         gpointer         user_data)
 940 {
 941   g_printf("Content\n");
 942 }
 943
 944
 945 void
 946 on_about_activate                      (GtkMenuItem     *menuitem,
 947                                         gpointer         user_data)
 948 {
 949   g_printf("About...\n");
 950 }
 951
 952
 953 void
 954 on_button_new_clicked                  (GtkButton       *button,
 955                                         gpointer         user_data)
 956 {
 957   create_new_window((GtkWidget*)button, user_data, FALSE);
 958 }
 959
 960
 961 void
 962 on_button_open_clicked                 (GtkButton       *button,
 963                                         gpointer         user_data)
 964 {
 965   open_traceset((GtkWidget*)button, user_data);
 966 }
 967
 968
 969 void
 970 on_button_add_trace_clicked            (GtkButton       *button,
 971                                         gpointer         user_data)
 972 {
 973   add_trace((GtkWidget*)button, user_data);
 974 }
 975
 976
 977 void
 978 on_button_remove_trace_clicked         (GtkButton       *button,
 979                                         gpointer         user_data)
 980 {
 981   remove_trace((GtkWidget*)button, user_data);
 982 }
 983
 984
 985 void
 986 on_button_save_clicked                 (GtkButton       *button,
 987                                         gpointer         user_data)
 988 {
 989   save((GtkWidget*)button, user_data);
 990 }
 991
 992
 993 void
 994 on_button_save_as_clicked              (GtkButton       *button,
 995                                         gpointer         user_data)
 996 {
 997   save_as((GtkWidget*)button, user_data);
 998 }
 999
1000
1001 void
1002 on_button_zoom_in_clicked              (GtkButton       *button,
1003                                         gpointer         user_data)
1004 {
1005    zoom_in((GtkWidget*)button, user_data);
1006 }
1007
1008
1009 void
1010 on_button_zoom_out_clicked             (GtkButton       *button,
1011                                         gpointer         user_data)
1012 {
1013    zoom_out((GtkWidget*)button, user_data);
1014 }
1015
1016
1017 void
1018 on_button_zoom_extended_clicked        (GtkButton       *button,
1019                                         gpointer         user_data)
1020 {
1021    zoom_extended((GtkWidget*)button, user_data);
1022 }
1023
1024
1025 void
1026 on_button_go_to_time_clicked           (GtkButton       *button,
1027                                         gpointer         user_data)
1028 {
1029    go_to_time((GtkWidget*)button, user_data);
1030 }
1031
1032
1033 void
1034 on_button_show_time_frame_clicked      (GtkButton       *button,
1035                                         gpointer         user_data)
1036 {
1037    show_time_frame((GtkWidget*)button, user_data);
1038 }
1039
1040
1041 void
1042 on_button_move_up_clicked              (GtkButton       *button,
1043                                         gpointer         user_data)
1044 {
1045   move_up_viewer((GtkWidget*)button, user_data);
1046 }
1047
1048
1049 void
1050 on_button_move_down_clicked            (GtkButton       *button,
1051                                         gpointer         user_data)
1052 {
1053   move_down_viewer((GtkWidget*)button, user_data);
1054 }
1055
1056
1057 void
1058 on_button_delete_viewer_clicked        (GtkButton       *button,
1059                                         gpointer         user_data)
1060 {
1061   delete_viewer((GtkWidget*)button, user_data);
1062 }
1063
1064 void
1065 on_MWindow_destroy                     (GtkObject       *object,
1066                                         gpointer         user_data)
1067 {
1068   MainWindow *Main_Window = (MainWindow*)user_data;
1069
1070   g_printf("There are : %d windows\n",g_slist_length(g_main_window_list));
1071
1072   g_win_count--;
1073   if(g_win_count == 0)
1074     gtk_main_quit ();
1075 }
1076
1077
1078 void
1079 on_MNotebook_switch_page               (GtkNotebook     *notebook,
1080                                         GtkNotebookPage *page,
1081                                         guint            page_num,
1082                                         gpointer         user_data)
1083 {
1084   MainWindow * mw = get_window_data_struct((GtkWidget*)notebook);
1085   Tab * tab = mw->tab;
1086
1087   while(page_num){
1088     tab = tab->next;
1089     page_num--;
1090   }
1091   mw->current_tab = tab;
1092 }
1093
1094 void checkbox_changed(GtkTreeView *treeview,
1095                       GtkTreePath *arg1,
1096                       GtkTreeViewColumn *arg2,
1097                       gpointer user_data)
1098 {
1099   GtkTreeStore * store = (GtkTreeStore *)gtk_tree_view_get_model (treeview);
1100   GtkTreeIter iter;
1101   gboolean value;
1102
1103   if (gtk_tree_model_get_iter ((GtkTreeModel *)store, &iter, arg1)){
1104     gtk_tree_model_get ((GtkTreeModel *)store, &iter, CHECKBOX_COLUMN, &value, -1);
1105     value = value? FALSE : TRUE;
1106     gtk_tree_store_set (GTK_TREE_STORE (store), &iter, CHECKBOX_COLUMN, value, -1);
1107   }
1108
1109 }
1110
1111 void update_filter(LttvTracesetSelector *s,  GtkTreeStore *store )
1112 {
1113   GtkTreeIter iter, child_iter;
1114   int i, j;
1115   LttvTraceSelector     * trace;
1116   LttvTracefileSelector * tracefile;
1117   gboolean value, value1;
1118
1119   if(gtk_tree_model_get_iter_first((GtkTreeModel*)store, &iter)){
1120     i = 0;
1121     do{
1122       trace = lttv_traceset_selector_get(s, i);
1123       gtk_tree_model_get ((GtkTreeModel*)store, &iter, CHECKBOX_COLUMN, &value,-1);
1124       if(value){
1125         j = 0;
1126         if(gtk_tree_model_iter_children ((GtkTreeModel*)store, &child_iter, &iter)){
1127           do{
1128             tracefile = lttv_trace_selector_get(trace, j);
1129             gtk_tree_model_get ((GtkTreeModel*)store, &child_iter, CHECKBOX_COLUMN, &value1,-1);
1130             lttv_tracefile_selector_set_selected(tracefile,value1);
1131             j++;
1132           }while(gtk_tree_model_iter_next((GtkTreeModel*)store, &child_iter));
1133         }
1134       }
1135       lttv_trace_selector_set_selected(trace,value);
1136       i++;
1137     }while(gtk_tree_model_iter_next((GtkTreeModel*)store, &iter));
1138   }
1139 }
1140
1141 gboolean get_filter_selection(LttvTracesetSelector *s,char *title, char * column_title)
1142 {
1143   GtkWidget         * dialogue;
1144   GtkTreeStore      * store;
1145   GtkWidget         * tree;
1146   GtkWidget         * scroll_win;
1147   GtkCellRenderer   * renderer;
1148   GtkTreeViewColumn * column;
1149   GtkTreeIter         iter, child_iter;
1150   int i, j, id, nb_trace, nb_tracefile;
1151   LttvTraceSelector     * trace;
1152   LttvTracefileSelector * tracefile;
1153   char * name;
1154   gboolean checked;
1155
1156   dialogue = gtk_dialog_new_with_buttons(title,
1157                                          NULL,
1158                                          GTK_DIALOG_MODAL,
1159                                          GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
1160                                          GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
1161                                          NULL);
1162   gtk_window_set_default_size((GtkWindow*)dialogue, 300, 100);
1163
1164   store = gtk_tree_store_new (TOTAL_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_STRING);
1165   tree  = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
1166   g_object_unref (G_OBJECT (store));
1167   g_signal_connect (G_OBJECT (tree), "row-activated",
1168                     G_CALLBACK (checkbox_changed),
1169                     NULL);
1170
1171
1172   renderer = gtk_cell_renderer_toggle_new ();
1173   gtk_cell_renderer_toggle_set_radio((GtkCellRendererToggle *)renderer, FALSE);
1174
1175   g_object_set (G_OBJECT (renderer),"activatable", TRUE, NULL);
1176
1177   column   = gtk_tree_view_column_new_with_attributes ("Checkbox",
1178                                                        renderer,
1179                                                        "active", CHECKBOX_COLUMN,
1180                                                        NULL);
1181   gtk_tree_view_column_set_alignment (column, 0.5);
1182   gtk_tree_view_column_set_fixed_width (column, 20);
1183   gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
1184
1185   renderer = gtk_cell_renderer_text_new ();
1186   column   = gtk_tree_view_column_new_with_attributes (column_title,
1187                                                        renderer,
1188                                                        "text", NAME_COLUMN,
1189                                                        NULL);
1190   gtk_tree_view_column_set_alignment (column, 0.0);
1191   gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
1192   gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (tree), FALSE);
1193
1194   scroll_win = gtk_scrolled_window_new (NULL, NULL);
1195   gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win),
1196                                  GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
1197   gtk_container_add (GTK_CONTAINER (scroll_win), tree);
1198
1199   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), scroll_win,TRUE, TRUE,0);
1200
1201   gtk_widget_show(scroll_win);
1202   gtk_widget_show(tree);
1203
1204   nb_trace = lttv_traceset_selector_number(s);
1205   for(i=0;i<nb_trace;i++){
1206     trace = lttv_traceset_selector_get(s, i);
1207     name  = lttv_trace_selector_get_name(trace);
1208     gtk_tree_store_append (store, &iter, NULL);
1209     checked = lttv_trace_selector_get_selected(trace);
1210     gtk_tree_store_set (store, &iter,
1211                         CHECKBOX_COLUMN,checked,
1212                         NAME_COLUMN,name,
1213                         -1);
1214     nb_tracefile = lttv_trace_selector_number(trace);
1215     for(j=0;j<nb_tracefile;j++){
1216       tracefile = lttv_trace_selector_get(trace, j);
1217       name      = lttv_tracefile_selector_get_name(tracefile);
1218       gtk_tree_store_append (store, &child_iter, &iter);
1219       checked = lttv_tracefile_selector_get_selected(tracefile);
1220       gtk_tree_store_set (store, &child_iter,
1221                           CHECKBOX_COLUMN, checked,
1222                           NAME_COLUMN,name,
1223                           -1);
1224     }
1225   }
1226
1227   id = gtk_dialog_run(GTK_DIALOG(dialogue));
1228   switch(id){
1229     case GTK_RESPONSE_ACCEPT:
1230     case GTK_RESPONSE_OK:
1231       update_filter(s, store);
1232       gtk_widget_destroy(dialogue);
1233       return TRUE;
1234     case GTK_RESPONSE_REJECT:
1235     case GTK_RESPONSE_CANCEL:
1236     default:
1237       gtk_widget_destroy(dialogue);
1238       break;
1239   }
1240   return FALSE;
1241 }
1242
1243 char * get_remove_trace(char ** all_trace_name, int nb_trace)
1244 {
1245   return get_selection(all_trace_name, nb_trace,
1246                        "Select a trace", "Trace pathname");
1247 }
1248 char * get_unload_module(char ** loaded_module_name, int nb_module)
1249 {
1250   return get_selection(loaded_module_name, nb_module,
1251                        "Select an unload module", "Module pathname");
1252 }
1253
1254 char * get_selection(char ** loaded_module_name, int nb_module,
1255                      char *title, char * column_title)
1256 {
1257   GtkWidget         * dialogue;
1258   GtkWidget         * scroll_win;
1259   GtkWidget         * tree;
1260   GtkListStore      * store;
1261   GtkTreeViewColumn * column;
1262   GtkCellRenderer   * renderer;
1263   GtkTreeSelection  * select;
1264   GtkTreeIter         iter;
1265   gint                id, i;
1266   char              * unload_module_name = NULL;
1267
1268   dialogue = gtk_dialog_new_with_buttons(title,
1269                                          NULL,
1270                                          GTK_DIALOG_MODAL,
1271                                          GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
1272                                          GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
1273                                          NULL);
1274   gtk_window_set_default_size((GtkWindow*)dialogue, 500, 200);
1275
1276   scroll_win = gtk_scrolled_window_new (NULL, NULL);
1277   gtk_widget_show ( scroll_win);
1278   gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win),
1279                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1280
1281   store = gtk_list_store_new (N_COLUMNS,G_TYPE_STRING);
1282   tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL (store));
1283   gtk_widget_show ( tree);
1284   g_object_unref (G_OBJECT (store));
1285
1286   renderer = gtk_cell_renderer_text_new ();
1287   column   = gtk_tree_view_column_new_with_attributes (column_title,
1288                                                      renderer,
1289                                                      "text", MODULE_COLUMN,
1290                                                      NULL);
1291   gtk_tree_view_column_set_alignment (column, 0.5);
1292   gtk_tree_view_column_set_fixed_width (column, 150);
1293   gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
1294
1295   select = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
1296   gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
1297
1298   gtk_container_add (GTK_CONTAINER (scroll_win), tree);
1299
1300   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), scroll_win,TRUE, TRUE,0);
1301
1302   for(i=0;i<nb_module;i++){
1303     gtk_list_store_append (store, &iter);
1304     gtk_list_store_set (store, &iter, MODULE_COLUMN,loaded_module_name[i],-1);
1305   }
1306
1307   id = gtk_dialog_run(GTK_DIALOG(dialogue));
1308   switch(id){
1309     case GTK_RESPONSE_ACCEPT:
1310     case GTK_RESPONSE_OK:
1311       if (gtk_tree_selection_get_selected (select, (GtkTreeModel**)&store, &iter)){
1312           gtk_tree_model_get ((GtkTreeModel*)store, &iter, MODULE_COLUMN, &unload_module_name, -1);
1313       }
1314     case GTK_RESPONSE_REJECT:
1315     case GTK_RESPONSE_CANCEL:
1316     default:
1317       gtk_widget_destroy(dialogue);
1318       break;
1319   }
1320
1321   return unload_module_name;
1322 }
1323
1324 void main_window_destroy_hash_key(gpointer key)
1325 {
1326   g_free(key);
1327 }
1328
1329 void main_window_destroy_hash_data(gpointer data)
1330 {
1331 }
1332
1333
1334 void insert_menu_toolbar_item(MainWindow * mw, gpointer user_data)
1335 {
1336   int i;
1337   GdkPixbuf *pixbuf;
1338   view_constructor constructor;
1339   LttvMenus * menu;
1340   LttvToolbars * toolbar;
1341   lttv_menu_closure *menu_item;
1342   lttv_toolbar_closure *toolbar_item;
1343   LttvAttributeValue value;
1344   LttvIAttribute *attributes = LTTV_IATTRIBUTE(lttv_global_attributes());
1345   GtkWidget * tool_menu_title_menu, *insert_view, *pixmap, *tmp;
1346
1347   g_assert(lttv_iattribute_find_by_path(attributes,
1348            "viewers/menu", LTTV_POINTER, &value));
1349   menu = (LttvMenus*)*(value.v_pointer);
1350
1351   if(menu){
1352     for(i=0;i<menu->len;i++){
1353       menu_item = &g_array_index(menu, lttv_menu_closure, i);
1354       tmp = g_hash_table_lookup(mw->hash_menu_item, g_strdup(menu_item->menuText));
1355       if(tmp)continue;
1356       constructor = menu_item->con;
1357       tool_menu_title_menu = lookup_widget(mw->mwindow,"ToolMenuTitle_menu");
1358       insert_view = gtk_menu_item_new_with_mnemonic (menu_item->menuText);
1359       gtk_widget_show (insert_view);
1360       gtk_container_add (GTK_CONTAINER (tool_menu_title_menu), insert_view);
1361       g_signal_connect ((gpointer) insert_view, "activate",
1362                         G_CALLBACK (insert_viewer_wrap),
1363                         constructor);
1364       g_hash_table_insert(mw->hash_menu_item, g_strdup(menu_item->menuText),
1365                           insert_view);
1366     }
1367   }
1368
1369   g_assert(lttv_iattribute_find_by_path(attributes,
1370            "viewers/toolbar", LTTV_POINTER, &value));
1371   toolbar = (LttvToolbars*)*(value.v_pointer);
1372
1373   if(toolbar){
1374     for(i=0;i<toolbar->len;i++){
1375       toolbar_item = &g_array_index(toolbar, lttv_toolbar_closure, i);
1376       tmp = g_hash_table_lookup(mw->hash_toolbar_item, g_strdup(toolbar_item->tooltip));
1377       if(tmp)continue;
1378       constructor = toolbar_item->con;
1379       tool_menu_title_menu = lookup_widget(mw->mwindow,"MToolbar2");
1380       pixbuf = gdk_pixbuf_new_from_xpm_data ((const char**)toolbar_item->pixmap);
1381       pixmap = gtk_image_new_from_pixbuf(pixbuf);
1382       insert_view = gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu),
1383                                                 GTK_TOOLBAR_CHILD_BUTTON,
1384                                                 NULL,
1385                                                 "",
1386                                                 toolbar_item->tooltip, NULL,
1387                                                 pixmap, NULL, NULL);
1388       gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (tool_menu_title_menu)->children)->data))->label), TRUE);
1389       gtk_widget_show (insert_view);
1390       gtk_container_set_border_width (GTK_CONTAINER (insert_view), 1);
1391       g_signal_connect ((gpointer) insert_view, "clicked",G_CALLBACK (insert_viewer_wrap),constructor);
1392       g_hash_table_insert(mw->hash_toolbar_item, g_strdup(toolbar_item->tooltip),
1393                           insert_view);
1394     }
1395   }
1396 }
1397
1398 void construct_main_window(MainWindow * parent, WindowCreationData * win_creation_data)
1399 {
1400   g_critical("construct_main_window()");
1401   GtkWidget  * new_window; /* New generated main window */
1402   MainWindow * new_m_window;/* New main window structure */
1403   GtkNotebook * notebook;
1404   LttvIAttribute *attributes =
1405           LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
1406   LttvAttributeValue value;
1407
1408   new_m_window = g_new(MainWindow, 1);
1409
1410   // Add the object's information to the module's array
1411   g_main_window_list = g_slist_append(g_main_window_list, new_m_window);
1412
1413
1414   new_window  = create_MWindow();
1415   gtk_widget_show (new_window);
1416
1417   new_m_window->attributes = attributes;
1418
1419   new_m_window->mwindow = new_window;
1420   new_m_window->tab = NULL;
1421   new_m_window->current_tab = NULL;
1422   new_m_window->attributes = LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
1423   if(parent){
1424     new_m_window->win_creation_data = parent->win_creation_data;
1425   }else{
1426     new_m_window->win_creation_data = win_creation_data;
1427   }
1428
1429   new_m_window->hash_menu_item = g_hash_table_new_full (g_str_hash, g_str_equal,
1430                                               main_window_destroy_hash_key,
1431                                               main_window_destroy_hash_data);
1432   new_m_window->hash_toolbar_item = g_hash_table_new_full (g_str_hash, g_str_equal,
1433                                               main_window_destroy_hash_key,
1434                                               main_window_destroy_hash_data);
1435
1436   insert_menu_toolbar_item(new_m_window, NULL);
1437
1438   g_object_set_data(G_OBJECT(new_window), "mainWindow", (gpointer)new_m_window);
1439
1440   //create a default tab
1441   notebook = (GtkNotebook *)lookup_widget(new_m_window->mwindow, "MNotebook");
1442   if(notebook == NULL){
1443     g_printf("Notebook does not exist\n");
1444     return;
1445   }
1446   //for now there is no name field in LttvTraceset structure
1447   //Use "Traceset" as the label for the default tab
1448   create_tab(NULL, new_m_window, notebook,"Traceset");
1449
1450   g_object_set_data_full(
1451                         G_OBJECT(new_m_window->mwindow),
1452                         "Main_Window_Data",
1453                         new_m_window,
1454                         (GDestroyNotify)main_window_free);
1455
1456   g_win_count++;
1457 }
1458
1459 void tab_destructor(Tab * tab_instance)
1460 {
1461   int i, nb, ref_count;
1462   LttvTrace * trace;
1463
1464   if(tab_instance->attributes)
1465     g_object_unref(tab_instance->attributes);
1466
1467   if(tab_instance->mw->tab == tab_instance){
1468     tab_instance->mw->tab = tab_instance->next;
1469   }else{
1470     Tab * tmp1, *tmp = tab_instance->mw->tab;
1471     while(tmp != tab_instance){
1472       tmp1 = tmp;
1473       tmp = tmp->next;
1474     }
1475     tmp1->next = tab_instance->next;
1476   }
1477
1478   if(tab_instance->traceset_info->traceset_context != NULL){
1479     lttv_context_fini(LTTV_TRACESET_CONTEXT(tab_instance->traceset_info->
1480                                             traceset_context));
1481     g_object_unref(tab_instance->traceset_info->traceset_context);
1482   }
1483   if(tab_instance->traceset_info->traceset != NULL) {
1484     nb = lttv_traceset_number(tab_instance->traceset_info->traceset);
1485     for(i = 0 ; i < nb ; i++) {
1486       trace = lttv_traceset_get(tab_instance->traceset_info->traceset, i);
1487       ref_count = lttv_trace_get_ref_number(trace);
1488       if(ref_count <= 1){
1489         ltt_trace_close(lttv_trace(trace));
1490       }
1491       lttv_trace_destroy(trace);
1492     }
1493   }
1494   lttv_traceset_destroy(tab_instance->traceset_info->traceset);
1495   g_free(tab_instance->traceset_info);
1496   g_free(tab_instance);
1497 }
1498
1499 void * create_tab(MainWindow * parent, MainWindow* current_window,
1500                   GtkNotebook * notebook, char * label)
1501 {
1502   GList * list;
1503   Tab * tmp_tab;
1504   MainWindow * mw_data = current_window;
1505   LttTime tmp_time;
1506
1507   tmp_tab = mw_data->tab;
1508   while(tmp_tab && tmp_tab->next) tmp_tab = tmp_tab->next;
1509   if(!tmp_tab){
1510     mw_data->current_tab = NULL;
1511     tmp_tab = g_new(Tab,1);
1512     mw_data->tab = tmp_tab;
1513   }else{
1514     tmp_tab->next = g_new(Tab,1);
1515     tmp_tab = tmp_tab->next;
1516   }
1517
1518   tmp_tab->traceset_info = g_new(TracesetInfo,1);
1519   if(parent){
1520     tmp_tab->traceset_info->traceset =
1521       lttv_traceset_copy(parent->current_tab->traceset_info->traceset);
1522   }else{
1523     if(mw_data->current_tab){
1524       tmp_tab->traceset_info->traceset =
1525         lttv_traceset_copy(mw_data->current_tab->traceset_info->traceset);
1526     }else{
1527       tmp_tab->traceset_info->traceset = lttv_traceset_new();
1528       /* Add the command line trace */
1529       if(g_init_trace != NULL)
1530         lttv_traceset_add(tmp_tab->traceset_info->traceset, g_init_trace);
1531     }
1532   }
1533   //FIXME copy not implemented in lower level
1534   tmp_tab->traceset_info->traceset_context =
1535     g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
1536   lttv_context_init(
1537             LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context),
1538                                   tmp_tab->traceset_info->traceset);
1539
1540   if(mw_data->current_tab){
1541     // Will have to read directly at the main window level, as we want
1542     // to be able to modify a traceset on the fly.
1543     tmp_tab->time_window      = mw_data->current_tab->time_window;
1544     tmp_tab->current_time     = mw_data->current_tab->current_time;
1545   }else{
1546     // Will have to read directly at the main window level, as we want
1547     // to be able to modify a traceset on the fly.
1548     // get_traceset_time_span(mw_data,&tmp_tab->traceStartTime, &tmp_tab->traceEndTime);
1549     tmp_tab->time_window.start_time   =
1550             LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->Time_Span->startTime;
1551     if(DEFAULT_TIME_WIDTH_S <
1552               LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->Time_Span->endTime.tv_sec)
1553       tmp_time.tv_sec = DEFAULT_TIME_WIDTH_S;
1554     else
1555       tmp_time.tv_sec =
1556               LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->Time_Span->endTime.tv_sec;
1557     tmp_time.tv_nsec = 0;
1558     tmp_tab->time_window.time_width = tmp_time ;
1559     tmp_tab->current_time.tv_sec =
1560        LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->Time_Span->startTime.tv_sec;
1561     tmp_tab->current_time.tv_nsec =
1562        LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->Time_Span->startTime.tv_nsec;
1563   }
1564   tmp_tab->attributes = LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
1565   //  mw_data->current_tab = tmp_tab;
1566   tmp_tab->multi_vpaned = (GtkMultiVPaned*)gtk_multi_vpaned_new();
1567   tmp_tab->multi_vpaned->mw = mw_data;
1568   gtk_widget_show((GtkWidget*)tmp_tab->multi_vpaned);
1569   tmp_tab->next = NULL;
1570   tmp_tab->mw   = mw_data;
1571
1572   tmp_tab->label = gtk_label_new (label);
1573   gtk_widget_show (tmp_tab->label);
1574
1575   g_object_set_data_full(
1576            G_OBJECT(tmp_tab->multi_vpaned),
1577            "Tab_Info",
1578            tmp_tab,
1579            (GDestroyNotify)tab_destructor);
1580
1581   gtk_notebook_append_page(notebook, (GtkWidget*)tmp_tab->multi_vpaned, tmp_tab->label);
1582   list = gtk_container_get_children(GTK_CONTAINER(notebook));
1583   gtk_notebook_set_current_page(notebook,g_list_length(list)-1);
1584 }
1585
1586 void remove_menu_item(gpointer main_win, gpointer user_data)
1587 {
1588   MainWindow * mw = (MainWindow *) main_win;
1589   lttv_menu_closure *menu_item = (lttv_menu_closure *)user_data;
1590   GtkWidget * tool_menu_title_menu, *insert_view;
1591
1592   tool_menu_title_menu = lookup_widget(mw->mwindow,"ToolMenuTitle_menu");
1593   insert_view = (GtkWidget*)g_hash_table_lookup(mw->hash_menu_item,
1594                                                 menu_item->menuText);
1595   if(insert_view){
1596     g_hash_table_remove(mw->hash_menu_item, menu_item->menuText);
1597     gtk_container_remove (GTK_CONTAINER (tool_menu_title_menu), insert_view);
1598   }
1599 }
1600
1601 void remove_toolbar_item(gpointer main_win, gpointer user_data)
1602 {
1603   MainWindow * mw = (MainWindow *) main_win;
1604   lttv_toolbar_closure *toolbar_item = (lttv_toolbar_closure *)user_data;
1605   GtkWidget * tool_menu_title_menu, *insert_view;
1606
1607
1608   tool_menu_title_menu = lookup_widget(mw->mwindow,"MToolbar2");
1609   insert_view = (GtkWidget*)g_hash_table_lookup(mw->hash_toolbar_item,
1610                                                 toolbar_item->tooltip);
1611   if(insert_view){
1612     g_hash_table_remove(mw->hash_toolbar_item, toolbar_item->tooltip);
1613     gtk_container_remove (GTK_CONTAINER (tool_menu_title_menu), insert_view);
1614   }
1615 }
1616
1617 /**
1618  * Remove menu and toolbar item when a module unloaded
1619  */
1620
1621 void main_window_remove_menu_item(lttv_constructor constructor)
1622 {
1623   int i;
1624   LttvMenus * menu;
1625   lttv_menu_closure *menu_item;
1626   LttvAttributeValue value;
1627   LttvIAttribute *attributes = LTTV_IATTRIBUTE(lttv_global_attributes());
1628
1629   g_assert(lttv_iattribute_find_by_path(attributes,
1630            "viewers/menu", LTTV_POINTER, &value));
1631   menu = (LttvMenus*)*(value.v_pointer);
1632
1633   if(menu){
1634     for(i=0;i<menu->len;i++){
1635       menu_item = &g_array_index(menu, lttv_menu_closure, i);
1636       if(menu_item->con != constructor) continue;
1637       if(g_main_window_list){
1638         g_slist_foreach(g_main_window_list, remove_menu_item, menu_item);
1639       }
1640       break;
1641     }
1642   }
1643
1644 }
1645
1646 void main_window_remove_toolbar_item(lttv_constructor constructor)
1647 {
1648   int i;
1649   LttvToolbars * toolbar;
1650   lttv_toolbar_closure *toolbar_item;
1651   LttvAttributeValue value;
1652   LttvIAttribute *attributes = LTTV_IATTRIBUTE(lttv_global_attributes());
1653
1654   g_assert(lttv_iattribute_find_by_path(attributes,
1655            "viewers/toolbar", LTTV_POINTER, &value));
1656   toolbar = (LttvToolbars*)*(value.v_pointer);
1657
1658   if(toolbar){
1659     for(i=0;i<toolbar->len;i++){
1660       toolbar_item = &g_array_index(toolbar, lttv_toolbar_closure, i);
1661       if(toolbar_item->con != constructor) continue;
1662       if(g_main_window_list){
1663         g_slist_foreach(g_main_window_list, remove_toolbar_item, toolbar_item);
1664       }
1665       break;
1666     }
1667   }
1668 }