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