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