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