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

   1 #ifdef HAVE_CONFIG_H
   2 #  include <config.h>
   3 #endif
   4
   5 #include <gtk/gtk.h>
   6 #include <gmodule.h>
   7
   8 #include "callbacks.h"
   9 #include "interface.h"
  10 #include "support.h"
  11 #include <lttv/mainWindow.h>
  12 #include <lttv/menu.h>
  13 #include <lttv/toolbar.h>
  14 #include <lttv/gtkTraceSet.h>
  15 #include <lttv/module.h>
  16 #include <lttv/gtkdirsel.h>
  17 #include <lttv/iattribute.h>
  18
  19 #define PATH_LENGTH          256
  20 #define DEFAULT_TIME_WIDTH_S   1
  21
  22 extern LttTrace *g_init_trace ;
  23
  24
  25 /** Array containing instanced objects. */
  26 extern GSList * g_main_window_list;
  27
  28 static int g_win_count = 0;
  29
  30 MainWindow * get_window_data_struct(GtkWidget * widget);
  31 char * get_unload_module(char ** loaded_module_name, int nb_module);
  32 char * get_remove_trace(char ** all_trace_name, int nb_trace);
  33 char * get_selection(char ** all_name, int nb, char *title, char * column_title);
  34 void * create_tab(GtkWidget* parent, GtkNotebook * notebook, char * label);
  35
  36 void insert_viewer(GtkWidget* widget, view_constructor constructor);
  37
  38 enum
  39 {
  40   MODULE_COLUMN,
  41   N_COLUMNS
  42 };
  43
  44
  45 void
  46 insert_viewer_wrap(GtkWidget *menuitem, gpointer user_data)
  47 {
  48   GdkWindow * win;
  49   GdkCursor * new;
  50   guint val = 20;
  51   GtkWidget* widget = menuitem;
  52   MainWindow * mw;
  53
  54   new = gdk_cursor_new(GDK_X_CURSOR);
  55   if(GTK_IS_MENU_ITEM(menuitem)){
  56     widget = lookup_widget(menuitem, "MToolbar2");
  57   }
  58   win = gtk_widget_get_parent_window(widget);
  59   gdk_window_set_cursor(win, new);
  60   gdk_cursor_unref(new);
  61   gdk_window_stick(win);
  62   gdk_window_unstick(win);
  63
  64   insert_viewer((GtkWidget*)menuitem, (view_constructor)user_data);
  65   //  selected_hook(&val);
  66
  67   gdk_window_set_cursor(win, NULL);
  68 }
  69
  70
  71 /* internal functions */
  72 void insert_viewer(GtkWidget* widget, view_constructor constructor)
  73 {
  74   GtkCustom * custom;
  75   MainWindow * mw_data;
  76   GtkWidget * viewer;
  77
  78   mw_data = get_window_data_struct(widget);
  79   if(!mw_data->current_tab) return;
  80   custom = mw_data->current_tab->custom;
  81
  82   viewer = (GtkWidget*)constructor(mw_data);
  83   if(viewer)
  84   {
  85     gtk_custom_widget_add(custom, viewer);
  86     // Added by MD
  87     //    g_object_unref(G_OBJECT(viewer));
  88   }
  89 }
  90
  91 void get_label_string (GtkWidget * text, gchar * label)
  92 {
  93   GtkEntry * entry = (GtkEntry*)text;
  94   if(strlen(gtk_entry_get_text(entry))!=0)
  95     strcpy(label,gtk_entry_get_text(entry));
  96 }
  97
  98 void get_label(GtkWindow * mw, gchar * str, gchar* dialogue_title, gchar * label_str)
  99 {
 100   GtkWidget * dialogue;
 101   GtkWidget * text;
 102   GtkWidget * label;
 103   gint id;
 104
 105   dialogue = gtk_dialog_new_with_buttons(dialogue_title,NULL,
 106                                          GTK_DIALOG_MODAL,
 107                                          GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
 108                                          GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
 109                                          NULL);
 110
 111   label = gtk_label_new(label_str);
 112   gtk_widget_show(label);
 113
 114   text = gtk_entry_new();
 115   gtk_widget_show(text);
 116
 117   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), label,TRUE, TRUE,0);
 118   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), text,FALSE, FALSE,0);
 119
 120   id = gtk_dialog_run(GTK_DIALOG(dialogue));
 121   switch(id){
 122     case GTK_RESPONSE_ACCEPT:
 123       get_label_string(text,str);
 124       gtk_widget_destroy(dialogue);
 125       break;
 126     case GTK_RESPONSE_REJECT:
 127     default:
 128       gtk_widget_destroy(dialogue);
 129       break;
 130   }
 131 }
 132
 133 MainWindow * get_window_data_struct(GtkWidget * widget)
 134 {
 135   GtkWidget * mw;
 136   MainWindow * mw_data;
 137
 138   mw = lookup_widget(widget, "MWindow");
 139   if(mw == NULL){
 140     g_printf("Main window does not exist\n");
 141     return;
 142   }
 143
 144   mw_data = (MainWindow *) g_object_get_data(G_OBJECT(mw),"mainWindow");
 145   if(mw_data == NULL){
 146     g_printf("Main window data does not exist\n");
 147     return;
 148   }
 149   return mw_data;
 150 }
 151
 152 void create_new_window(GtkWidget* widget, gpointer user_data, gboolean clone)
 153 {
 154   MainWindow * parent = get_window_data_struct(widget);
 155
 156   if(clone){
 157     g_printf("Clone : use the same traceset\n");
 158     construct_main_window(parent, NULL, FALSE);
 159   }else{
 160     g_printf("Empty : traceset is set to NULL\n");
 161     construct_main_window(NULL, parent->win_creation_data, FALSE);
 162   }
 163 }
 164
 165 void move_up_viewer(GtkWidget * widget, gpointer user_data)
 166 {
 167   MainWindow * mw = get_window_data_struct(widget);
 168   if(!mw->current_tab) return;
 169   gtk_custom_widget_move_up(mw->current_tab->custom);
 170 }
 171
 172 void move_down_viewer(GtkWidget * widget, gpointer user_data)
 173 {
 174   MainWindow * mw = get_window_data_struct(widget);
 175   if(!mw->current_tab) return;
 176   gtk_custom_widget_move_down(mw->current_tab->custom);
 177 }
 178
 179 void delete_viewer(GtkWidget * widget, gpointer user_data)
 180 {
 181   MainWindow * mw = get_window_data_struct(widget);
 182   if(!mw->current_tab) return;
 183   gtk_custom_widget_delete(mw->current_tab->custom);
 184 }
 185
 186 void open_traceset(GtkWidget * widget, gpointer user_data)
 187 {
 188   char ** dir;
 189   gint id;
 190   LttvTraceset * traceset;
 191   MainWindow * mw_data = get_window_data_struct(widget);
 192   GtkFileSelection * file_selector =
 193     (GtkFileSelection *)gtk_file_selection_new("Select a traceset");
 194
 195   gtk_file_selection_hide_fileop_buttons(file_selector);
 196
 197   id = gtk_dialog_run(GTK_DIALOG(file_selector));
 198   switch(id){
 199     case GTK_RESPONSE_ACCEPT:
 200     case GTK_RESPONSE_OK:
 201       dir = gtk_file_selection_get_selections (file_selector);
 202       traceset = lttv_traceset_load(dir[0]);
 203       g_printf("Open a trace set %s\n", dir[0]);
 204       //Not finished yet
 205       g_strfreev(dir);
 206     case GTK_RESPONSE_REJECT:
 207     case GTK_RESPONSE_CANCEL:
 208     default:
 209       gtk_widget_destroy((GtkWidget*)file_selector);
 210       break;
 211   }
 212
 213 }
 214
 215 void add_trace(GtkWidget * widget, gpointer user_data)
 216 {
 217   LttTrace *trace;
 218   LttvTrace * trace_v;
 219   LttvTraceset * traceset;
 220   char * dir;
 221   gint id;
 222   MainWindow * mw_data = get_window_data_struct(widget);
 223   GtkDirSelection * file_selector = (GtkDirSelection *)gtk_dir_selection_new("Select a trace");
 224   gtk_dir_selection_hide_fileop_buttons(file_selector);
 225
 226   id = gtk_dialog_run(GTK_DIALOG(file_selector));
 227   switch(id){
 228     case GTK_RESPONSE_ACCEPT:
 229     case GTK_RESPONSE_OK:
 230       dir = gtk_dir_selection_get_dir (file_selector);
 231       trace = ltt_trace_open(dir);
 232       if(trace == NULL) g_critical("cannot open trace %s", dir);
 233       trace_v = lttv_trace_new(trace);
 234       traceset = mw_data->traceset_info->traceset;
 235       if(mw_data->traceset_info->traceset_context != NULL){
 236         lttv_context_fini(LTTV_TRACESET_CONTEXT(mw_data->traceset_info->traceset_context));
 237         g_object_unref(mw_data->traceset_info->traceset_context);
 238       }
 239       lttv_traceset_add(traceset, trace_v);
 240       mw_data->traceset_info->traceset_context =
 241         g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
 242       lttv_context_init(
 243         LTTV_TRACESET_CONTEXT(mw_data->traceset_info->traceset_context),traceset);
 244     case GTK_RESPONSE_REJECT:
 245     case GTK_RESPONSE_CANCEL:
 246     default:
 247       gtk_widget_destroy((GtkWidget*)file_selector);
 248       break;
 249   }
 250
 251   g_printf("add a trace to a trace set\n");
 252 }
 253
 254 void remove_trace(GtkWidget * widget, gpointer user_data)
 255 {
 256   LttTrace *trace;
 257   LttvTrace * trace_v;
 258   LttvTraceset * traceset;
 259   gint i, nb_trace;
 260   char ** name, *remove_trace_name;
 261   MainWindow * mw_data = get_window_data_struct(widget);
 262
 263   nb_trace =lttv_traceset_number(mw_data->traceset_info->traceset);
 264   name = g_new(char*,nb_trace);
 265   for(i = 0; i < nb_trace; i++){
 266     trace_v = lttv_traceset_get(mw_data->traceset_info->traceset, i);
 267     trace = lttv_trace(trace_v);
 268     name[i] = trace->pathname;
 269   }
 270
 271   remove_trace_name = get_remove_trace(name, nb_trace);
 272
 273   if(remove_trace_name){
 274     for(i=0; i<nb_trace; i++){
 275       if(strcmp(remove_trace_name,name[i]) == 0){
 276         traceset = mw_data->traceset_info->traceset;
 277         if(mw_data->traceset_info->traceset_context != NULL){
 278           lttv_context_fini(LTTV_TRACESET_CONTEXT(mw_data->traceset_info->traceset_context));
 279           g_object_unref(mw_data->traceset_info->traceset_context);
 280         }
 281         lttv_traceset_remove(traceset, i);
 282         mw_data->traceset_info->traceset_context =
 283           g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
 284         lttv_context_init(
 285           LTTV_TRACESET_CONTEXT(mw_data->traceset_info->traceset_context),traceset);
 286         break;
 287       }
 288     }
 289   }
 290
 291   g_free(name);
 292   g_printf("remove a trace from a trace set\n");
 293 }
 294
 295 void save(GtkWidget * widget, gpointer user_data)
 296 {
 297   g_printf("Save\n");
 298 }
 299
 300 void save_as(GtkWidget * widget, gpointer user_data)
 301 {
 302   g_printf("Save as\n");
 303 }
 304
 305 void zoom(GtkWidget * widget, double size)
 306 {
 307   TimeInterval *time_span;
 308   TimeWindow time_window;
 309   LttTime    current_time, time_delta, time_s, time_e;
 310   MainWindow * mw_data = get_window_data_struct(widget);
 311
 312   time_span = LTTV_TRACESET_CONTEXT(mw_data->traceset_info->traceset_context)->Time_Span ;
 313   time_window =  mw_data->current_tab->time_window;
 314   current_time = mw_data->current_tab->current_time;
 315
 316   time_delta = ltt_time_sub(time_span->endTime,time_span->startTime);
 317   if(size == 0){
 318     time_window.start_time = time_span->startTime;
 319     time_window.time_width = time_delta;
 320   }else{
 321     time_window.time_width = ltt_time_div(time_window.time_width, size);
 322     if(ltt_time_compare(time_window.time_width,time_delta) > 0)
 323       time_window.time_width = time_delta;
 324
 325     time_s = ltt_time_sub(current_time,ltt_time_div(time_window.time_width, 2));
 326     time_e = ltt_time_add(current_time,ltt_time_div(time_window.time_width, 2));
 327     if(ltt_time_compare(time_span->startTime, time_s) > 0){
 328       time_s = time_span->startTime;
 329     }else if(ltt_time_compare(time_span->endTime, time_e) < 0){
 330       time_e = time_span->endTime;
 331       time_s = ltt_time_sub(time_e,time_window.time_width);
 332     }
 333     time_window.start_time = time_s;
 334   }
 335   set_time_window(mw_data, &time_window);
 336   gtk_custom_set_adjust(mw_data->current_tab->custom, FALSE);
 337 }
 338
 339 void zoom_in(GtkWidget * widget, gpointer user_data)
 340 {
 341   zoom(widget, 2);
 342 }
 343
 344 void zoom_out(GtkWidget * widget, gpointer user_data)
 345 {
 346   zoom(widget, 0.5);
 347 }
 348
 349 void zoom_extended(GtkWidget * widget, gpointer user_data)
 350 {
 351   zoom(widget, 0);
 352 }
 353
 354 void go_to_time(GtkWidget * widget, gpointer user_data)
 355 {
 356   g_printf("Go to time\n");
 357 }
 358
 359 void show_time_frame(GtkWidget * widget, gpointer user_data)
 360 {
 361   g_printf("Show time frame\n");
 362 }
 363
 364
 365 /* callback function */
 366
 367 void
 368 on_empty_traceset_activate             (GtkMenuItem     *menuitem,
 369                                         gpointer         user_data)
 370 {
 371   create_new_window((GtkWidget*)menuitem, user_data, FALSE);
 372 }
 373
 374
 375 void
 376 on_clone_traceset_activate             (GtkMenuItem     *menuitem,
 377                                         gpointer         user_data)
 378 {
 379   create_new_window((GtkWidget*)menuitem, user_data, TRUE);
 380 }
 381
 382
 383 void
 384 on_tab_activate                        (GtkMenuItem     *menuitem,
 385                                         gpointer         user_data)
 386 {
 387   gchar label[PATH_LENGTH];
 388   GtkNotebook * notebook = (GtkNotebook *)lookup_widget((GtkWidget*)menuitem, "MNotebook");
 389   if(notebook == NULL){
 390     g_printf("Notebook does not exist\n");
 391     return;
 392   }
 393
 394   strcpy(label,"Page");
 395   get_label(NULL, label,"Get the name of the tab","Please input tab's name");
 396
 397   create_tab ((GtkWidget*)menuitem, notebook, label);
 398 }
 399
 400
 401 void
 402 on_open_activate                       (GtkMenuItem     *menuitem,
 403                                         gpointer         user_data)
 404 {
 405   open_traceset((GtkWidget*)menuitem, user_data);
 406 }
 407
 408
 409 void
 410 on_close_activate                      (GtkMenuItem     *menuitem,
 411                                         gpointer         user_data)
 412 {
 413   MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
 414   main_window_destructor(mw_data);
 415 }
 416
 417
 418 void
 419 on_close_tab_activate                  (GtkMenuItem     *menuitem,
 420                                         gpointer         user_data)
 421 {
 422   int count = 0;
 423   GtkWidget * notebook;
 424   Tab * tmp;
 425   MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
 426   notebook = lookup_widget((GtkWidget*)menuitem, "MNotebook");
 427   if(notebook == NULL){
 428     g_printf("Notebook does not exist\n");
 429     return;
 430   }
 431
 432   if(mw_data->tab == mw_data->current_tab){
 433     //    tmp = mw_data->current_tb;
 434     //    mw_data->tab = mw_data->current_tab->next;
 435     g_printf("The default TAB can not be deleted\n");
 436     return;
 437   }else{
 438     tmp = mw_data->tab;
 439     while(tmp != mw_data->current_tab){
 440       tmp = tmp->next;
 441       count++;
 442     }
 443   }
 444
 445   gtk_notebook_remove_page((GtkNotebook*)notebook, count);
 446 }
 447
 448
 449 void
 450 on_add_trace_activate                  (GtkMenuItem     *menuitem,
 451                                         gpointer         user_data)
 452 {
 453   add_trace((GtkWidget*)menuitem, user_data);
 454 }
 455
 456
 457 void
 458 on_remove_trace_activate               (GtkMenuItem     *menuitem,
 459                                         gpointer         user_data)
 460 {
 461   remove_trace((GtkWidget*)menuitem, user_data);
 462 }
 463
 464
 465 void
 466 on_save_activate                       (GtkMenuItem     *menuitem,
 467                                         gpointer         user_data)
 468 {
 469   save((GtkWidget*)menuitem, user_data);
 470 }
 471
 472
 473 void
 474 on_save_as_activate                    (GtkMenuItem     *menuitem,
 475                                         gpointer         user_data)
 476 {
 477   save_as((GtkWidget*)menuitem, user_data);
 478 }
 479
 480
 481 void
 482 on_quit_activate                       (GtkMenuItem     *menuitem,
 483                                         gpointer         user_data)
 484 {
 485   gtk_main_quit ();
 486 }
 487
 488
 489 void
 490 on_cut_activate                        (GtkMenuItem     *menuitem,
 491                                         gpointer         user_data)
 492 {
 493   g_printf("Cut\n");
 494 }
 495
 496
 497 void
 498 on_copy_activate                       (GtkMenuItem     *menuitem,
 499                                         gpointer         user_data)
 500 {
 501   g_printf("Copye\n");
 502 }
 503
 504
 505 void
 506 on_paste_activate                      (GtkMenuItem     *menuitem,
 507                                         gpointer         user_data)
 508 {
 509   g_printf("Paste\n");
 510 }
 511
 512
 513 void
 514 on_delete_activate                     (GtkMenuItem     *menuitem,
 515                                         gpointer         user_data)
 516 {
 517   g_printf("Delete\n");
 518 }
 519
 520
 521 void
 522 on_zoom_in_activate                    (GtkMenuItem     *menuitem,
 523                                         gpointer         user_data)
 524 {
 525    zoom_in((GtkWidget*)menuitem, user_data);
 526 }
 527
 528
 529 void
 530 on_zoom_out_activate                   (GtkMenuItem     *menuitem,
 531                                         gpointer         user_data)
 532 {
 533    zoom_out((GtkWidget*)menuitem, user_data);
 534 }
 535
 536
 537 void
 538 on_zoom_extended_activate              (GtkMenuItem     *menuitem,
 539                                         gpointer         user_data)
 540 {
 541    zoom_extended((GtkWidget*)menuitem, user_data);
 542 }
 543
 544
 545 void
 546 on_go_to_time_activate                 (GtkMenuItem     *menuitem,
 547                                         gpointer         user_data)
 548 {
 549    go_to_time((GtkWidget*)menuitem, user_data);
 550 }
 551
 552
 553 void
 554 on_show_time_frame_activate            (GtkMenuItem     *menuitem,
 555                                         gpointer         user_data)
 556 {
 557    show_time_frame((GtkWidget*)menuitem, user_data);
 558 }
 559
 560
 561 void
 562 on_move_viewer_up_activate             (GtkMenuItem     *menuitem,
 563                                         gpointer         user_data)
 564 {
 565   move_up_viewer((GtkWidget*)menuitem, user_data);
 566 }
 567
 568
 569 void
 570 on_move_viewer_down_activate           (GtkMenuItem     *menuitem,
 571                                         gpointer         user_data)
 572 {
 573   move_down_viewer((GtkWidget*)menuitem, user_data);
 574 }
 575
 576
 577 void
 578 on_remove_viewer_activate              (GtkMenuItem     *menuitem,
 579                                         gpointer         user_data)
 580 {
 581   delete_viewer((GtkWidget*)menuitem, user_data);
 582 }
 583
 584
 585 void
 586 on_load_module_activate                (GtkMenuItem     *menuitem,
 587                                         gpointer         user_data)
 588 {
 589   char ** dir;
 590   gint id;
 591   char str[PATH_LENGTH], *str1;
 592   MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
 593   GtkFileSelection * file_selector = (GtkFileSelection *)gtk_file_selection_new("Select a module");
 594   gtk_file_selection_hide_fileop_buttons(file_selector);
 595
 596   str[0] = '\0';
 597   id = gtk_dialog_run(GTK_DIALOG(file_selector));
 598   switch(id){
 599     case GTK_RESPONSE_ACCEPT:
 600     case GTK_RESPONSE_OK:
 601       dir = gtk_file_selection_get_selections (file_selector);
 602       sprintf(str,dir[0]);
 603       str1 = strrchr(str,'/');
 604       if(str1)str1++;
 605       else{
 606         str1 = strrchr(str,'\\');
 607         str1++;
 608       }
 609       if(mw_data->win_creation_data)
 610         lttv_module_load(str1, mw_data->win_creation_data->argc,mw_data->win_creation_data->argv);
 611       else
 612         lttv_module_load(str1, 0,NULL);
 613       g_slist_foreach(g_main_window_list, insert_menu_toolbar_item, NULL);
 614       g_strfreev(dir);
 615     case GTK_RESPONSE_REJECT:
 616     case GTK_RESPONSE_CANCEL:
 617     default:
 618       gtk_widget_destroy((GtkWidget*)file_selector);
 619       break;
 620   }
 621   g_printf("Load module: %s\n", str);
 622 }
 623
 624
 625 void
 626 on_unload_module_activate              (GtkMenuItem     *menuitem,
 627                                         gpointer         user_data)
 628 {
 629   int i;
 630   char **name, *unload_module_name;
 631   guint nb;
 632   LttvModule ** modules, *module;
 633   MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
 634
 635   modules = lttv_module_list(&nb);
 636   name  = g_new(char*, nb);
 637   for(i=0;i<nb;i++){
 638     module = modules[i];
 639     name[i] = lttv_module_name(module);
 640   }
 641
 642   unload_module_name =get_unload_module(name,nb);
 643
 644   if(unload_module_name){
 645     for(i=0;i<nb;i++){
 646       if(strcmp(unload_module_name, name[i]) == 0){
 647         lttv_module_unload(modules[i]);
 648         break;
 649       }
 650     }
 651   }
 652
 653   g_free(name);
 654 }
 655
 656
 657 void
 658 on_add_module_search_path_activate     (GtkMenuItem     *menuitem,
 659                                         gpointer         user_data)
 660 {
 661   GtkDirSelection * file_selector = (GtkDirSelection *)gtk_dir_selection_new("Select module path");
 662   char * dir;
 663   gint id;
 664
 665   MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
 666
 667   id = gtk_dialog_run(GTK_DIALOG(file_selector));
 668   switch(id){
 669     case GTK_RESPONSE_ACCEPT:
 670     case GTK_RESPONSE_OK:
 671       dir = gtk_dir_selection_get_dir (file_selector);
 672       lttv_module_path_add(dir);
 673     case GTK_RESPONSE_REJECT:
 674     case GTK_RESPONSE_CANCEL:
 675     default:
 676       gtk_widget_destroy((GtkWidget*)file_selector);
 677       break;
 678   }
 679 }
 680
 681
 682 void
 683 on_color_activate                      (GtkMenuItem     *menuitem,
 684                                         gpointer         user_data)
 685 {
 686   g_printf("Color\n");
 687 }
 688
 689
 690 void
 691 on_filter_activate                     (GtkMenuItem     *menuitem,
 692                                         gpointer         user_data)
 693 {
 694   g_printf("Filter\n");
 695 }
 696
 697
 698 void
 699 on_save_configuration_activate         (GtkMenuItem     *menuitem,
 700                                         gpointer         user_data)
 701 {
 702   g_printf("Save configuration\n");
 703 }
 704
 705
 706 void
 707 on_content_activate                    (GtkMenuItem     *menuitem,
 708                                         gpointer         user_data)
 709 {
 710   g_printf("Content\n");
 711 }
 712
 713
 714 void
 715 on_about_activate                      (GtkMenuItem     *menuitem,
 716                                         gpointer         user_data)
 717 {
 718   g_printf("About...\n");
 719 }
 720
 721
 722 void
 723 on_button_new_clicked                  (GtkButton       *button,
 724                                         gpointer         user_data)
 725 {
 726   create_new_window((GtkWidget*)button, user_data, FALSE);
 727 }
 728
 729
 730 void
 731 on_button_open_clicked                 (GtkButton       *button,
 732                                         gpointer         user_data)
 733 {
 734   open_traceset((GtkWidget*)button, user_data);
 735 }
 736
 737
 738 void
 739 on_button_add_trace_clicked            (GtkButton       *button,
 740                                         gpointer         user_data)
 741 {
 742   add_trace((GtkWidget*)button, user_data);
 743 }
 744
 745
 746 void
 747 on_button_remove_trace_clicked         (GtkButton       *button,
 748                                         gpointer         user_data)
 749 {
 750   remove_trace((GtkWidget*)button, user_data);
 751 }
 752
 753
 754 void
 755 on_button_save_clicked                 (GtkButton       *button,
 756                                         gpointer         user_data)
 757 {
 758   save((GtkWidget*)button, user_data);
 759 }
 760
 761
 762 void
 763 on_button_save_as_clicked              (GtkButton       *button,
 764                                         gpointer         user_data)
 765 {
 766   save_as((GtkWidget*)button, user_data);
 767 }
 768
 769
 770 void
 771 on_button_zoom_in_clicked              (GtkButton       *button,
 772                                         gpointer         user_data)
 773 {
 774    zoom_in((GtkWidget*)button, user_data);
 775 }
 776
 777
 778 void
 779 on_button_zoom_out_clicked             (GtkButton       *button,
 780                                         gpointer         user_data)
 781 {
 782    zoom_out((GtkWidget*)button, user_data);
 783 }
 784
 785
 786 void
 787 on_button_zoom_extended_clicked        (GtkButton       *button,
 788                                         gpointer         user_data)
 789 {
 790    zoom_extended((GtkWidget*)button, user_data);
 791 }
 792
 793
 794 void
 795 on_button_go_to_time_clicked           (GtkButton       *button,
 796                                         gpointer         user_data)
 797 {
 798    go_to_time((GtkWidget*)button, user_data);
 799 }
 800
 801
 802 void
 803 on_button_show_time_frame_clicked      (GtkButton       *button,
 804                                         gpointer         user_data)
 805 {
 806    show_time_frame((GtkWidget*)button, user_data);
 807 }
 808
 809
 810 void
 811 on_button_move_up_clicked              (GtkButton       *button,
 812                                         gpointer         user_data)
 813 {
 814   move_up_viewer((GtkWidget*)button, user_data);
 815 }
 816
 817
 818 void
 819 on_button_move_down_clicked            (GtkButton       *button,
 820                                         gpointer         user_data)
 821 {
 822   move_down_viewer((GtkWidget*)button, user_data);
 823 }
 824
 825
 826 void
 827 on_button_delete_viewer_clicked        (GtkButton       *button,
 828                                         gpointer         user_data)
 829 {
 830   delete_viewer((GtkWidget*)button, user_data);
 831 }
 832
 833 void
 834 on_MWindow_destroy                     (GtkObject       *object,
 835                                         gpointer         user_data)
 836 {
 837   MainWindow *Main_Window = (MainWindow*)user_data;
 838
 839   g_printf("There are : %d windows\n",g_slist_length(g_main_window_list));
 840
 841   g_win_count--;
 842   if(g_win_count == 0)
 843     gtk_main_quit ();
 844 }
 845
 846
 847 void
 848 on_MNotebook_switch_page               (GtkNotebook     *notebook,
 849                                         GtkNotebookPage *page,
 850                                         guint            page_num,
 851                                         gpointer         user_data)
 852 {
 853   MainWindow * mw = get_window_data_struct((GtkWidget*)notebook);
 854   Tab * tab = mw->tab;
 855
 856   while(page_num){
 857     tab = tab->next;
 858     page_num--;
 859   }
 860   mw->current_tab = tab;
 861 }
 862
 863 char * get_remove_trace(char ** all_trace_name, int nb_trace)
 864 {
 865   return get_selection(all_trace_name, nb_trace,
 866                        "Select a trace", "Trace pathname");
 867 }
 868 char * get_unload_module(char ** loaded_module_name, int nb_module)
 869 {
 870   return get_selection(loaded_module_name, nb_module,
 871                        "Select an unload module", "Module pathname");
 872 }
 873
 874 char * get_selection(char ** loaded_module_name, int nb_module,
 875                      char *title, char * column_title)
 876 {
 877   GtkWidget         * dialogue;
 878   GtkWidget         * scroll_win;
 879   GtkWidget         * tree;
 880   GtkListStore      * store;
 881   GtkTreeViewColumn * column;
 882   GtkCellRenderer   * renderer;
 883   GtkTreeSelection  * select;
 884   GtkTreeIter         iter;
 885   gint                id, i;
 886   char              * unload_module_name = NULL;
 887
 888   dialogue = gtk_dialog_new_with_buttons(title,
 889                                          NULL,
 890                                          GTK_DIALOG_MODAL,
 891                                          GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
 892                                          GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
 893                                          NULL);
 894   gtk_window_set_default_size((GtkWindow*)dialogue, 500, 200);
 895
 896   scroll_win = gtk_scrolled_window_new (NULL, NULL);
 897   gtk_widget_show ( scroll_win);
 898   gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win),
 899                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 900
 901   store = gtk_list_store_new (N_COLUMNS,G_TYPE_STRING);
 902   tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL (store));
 903   gtk_widget_show ( tree);
 904   g_object_unref (G_OBJECT (store));
 905
 906   renderer = gtk_cell_renderer_text_new ();
 907   column   = gtk_tree_view_column_new_with_attributes (column_title,
 908                                                      renderer,
 909                                                      "text", MODULE_COLUMN,
 910                                                      NULL);
 911   gtk_tree_view_column_set_alignment (column, 0.5);
 912   gtk_tree_view_column_set_fixed_width (column, 150);
 913   gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
 914
 915   select = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
 916   gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
 917
 918   gtk_container_add (GTK_CONTAINER (scroll_win), tree);
 919
 920   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), scroll_win,TRUE, TRUE,0);
 921
 922   for(i=0;i<nb_module;i++){
 923     gtk_list_store_append (store, &iter);
 924     gtk_list_store_set (store, &iter, MODULE_COLUMN,loaded_module_name[i],-1);
 925   }
 926
 927   id = gtk_dialog_run(GTK_DIALOG(dialogue));
 928   switch(id){
 929     case GTK_RESPONSE_ACCEPT:
 930     case GTK_RESPONSE_OK:
 931       if (gtk_tree_selection_get_selected (select, (GtkTreeModel**)&store, &iter)){
 932           gtk_tree_model_get ((GtkTreeModel*)store, &iter, MODULE_COLUMN, &unload_module_name, -1);
 933       }
 934     case GTK_RESPONSE_REJECT:
 935     case GTK_RESPONSE_CANCEL:
 936     default:
 937       gtk_widget_destroy(dialogue);
 938       break;
 939   }
 940
 941   return unload_module_name;
 942 }
 943
 944 void main_window_destroy_hash_key(gpointer key)
 945 {
 946   g_free(key);
 947 }
 948
 949 void main_window_destroy_hash_data(gpointer data)
 950 {
 951 }
 952
 953
 954 void insert_menu_toolbar_item(MainWindow * mw, gpointer user_data)
 955 {
 956   int i;
 957   GdkPixbuf *pixbuf;
 958   view_constructor constructor;
 959   LttvMenus * menu;
 960   LttvToolbars * toolbar;
 961   lttv_menu_closure *menu_item;
 962   lttv_toolbar_closure *toolbar_item;
 963   LttvAttributeValue value;
 964   LttvIAttribute *attributes = LTTV_IATTRIBUTE(lttv_global_attributes());
 965   GtkWidget * tool_menu_title_menu, *insert_view, *pixmap, *tmp;
 966
 967   g_assert(lttv_iattribute_find_by_path(attributes,
 968            "viewers/menu", LTTV_POINTER, &value));
 969   menu = (LttvMenus*)*(value.v_pointer);
 970
 971   if(menu){
 972     for(i=0;i<menu->len;i++){
 973       menu_item = &g_array_index(menu, lttv_menu_closure, i);
 974       tmp = g_hash_table_lookup(mw->hash_menu_item, g_strdup(menu_item->menuText));
 975       if(tmp)continue;
 976       constructor = menu_item->con;
 977       tool_menu_title_menu = lookup_widget(mw->mwindow,"ToolMenuTitle_menu");
 978       insert_view = gtk_menu_item_new_with_mnemonic (menu_item->menuText);
 979       gtk_widget_show (insert_view);
 980       gtk_container_add (GTK_CONTAINER (tool_menu_title_menu), insert_view);
 981       g_signal_connect ((gpointer) insert_view, "activate",
 982                         G_CALLBACK (insert_viewer_wrap),
 983                         constructor);
 984       g_hash_table_insert(mw->hash_menu_item, g_strdup(menu_item->menuText),
 985                           insert_view);
 986     }
 987   }
 988
 989   g_assert(lttv_iattribute_find_by_path(attributes,
 990            "viewers/toolbar", LTTV_POINTER, &value));
 991   toolbar = (LttvToolbars*)*(value.v_pointer);
 992
 993   if(toolbar){
 994     for(i=0;i<toolbar->len;i++){
 995       toolbar_item = &g_array_index(toolbar, lttv_toolbar_closure, i);
 996       tmp = g_hash_table_lookup(mw->hash_toolbar_item, g_strdup(toolbar_item->tooltip));
 997       if(tmp)continue;
 998       constructor = toolbar_item->con;
 999       tool_menu_title_menu = lookup_widget(mw->mwindow,"MToolbar2");
1000       pixbuf = gdk_pixbuf_new_from_xpm_data ((const char**)toolbar_item->pixmap);
1001       pixmap = gtk_image_new_from_pixbuf(pixbuf);
1002       insert_view = gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu),
1003                                                 GTK_TOOLBAR_CHILD_BUTTON,
1004                                                 NULL,
1005                                                 "",
1006                                                 toolbar_item->tooltip, NULL,
1007                                                 pixmap, NULL, NULL);
1008       gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (tool_menu_title_menu)->children)->data))->label), TRUE);
1009       gtk_widget_show (insert_view);
1010       gtk_container_set_border_width (GTK_CONTAINER (insert_view), 1);
1011       g_signal_connect ((gpointer) insert_view, "clicked",G_CALLBACK (insert_viewer_wrap),constructor);
1012       g_hash_table_insert(mw->hash_toolbar_item, g_strdup(toolbar_item->tooltip),
1013                           insert_view);
1014     }
1015   }
1016 }
1017
1018 void construct_main_window(MainWindow * parent, WindowCreationData * win_creation_data,
1019                       gboolean first_window)
1020 {
1021   g_critical("construct_main_window()");
1022   GtkWidget  * new_window; /* New generated main window */
1023   MainWindow * new_m_window;/* New main window structure */
1024   GtkNotebook * notebook;
1025   LttvIAttribute *attributes =
1026           LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
1027   LttvAttributeValue value;
1028
1029   new_m_window = g_new(MainWindow, 1);
1030
1031   // Add the object's information to the module's array
1032   g_main_window_list = g_slist_append(g_main_window_list, new_m_window);
1033
1034
1035   new_window  = create_MWindow();
1036   gtk_widget_show (new_window);
1037
1038   new_m_window->attributes = attributes;
1039
1040   new_m_window->traceset_info = g_new(TracesetInfo,1);
1041   new_m_window->traceset_info->path = NULL ;
1042
1043
1044   new_m_window->traceset_info->before_traceset = lttv_hooks_new();
1045   new_m_window->traceset_info->after_traceset = lttv_hooks_new();
1046   new_m_window->traceset_info->before_trace = lttv_hooks_new();
1047   new_m_window->traceset_info->after_trace = lttv_hooks_new();
1048   new_m_window->traceset_info->before_tracefile = lttv_hooks_new();
1049   new_m_window->traceset_info->after_tracefile = lttv_hooks_new();
1050   new_m_window->traceset_info->before_event = lttv_hooks_new();
1051   new_m_window->traceset_info->after_event = lttv_hooks_new();
1052
1053   g_assert(lttv_iattribute_find_by_path(attributes, "hooks/traceset/before",
1054       LTTV_POINTER, &value));
1055   *(value.v_pointer) = new_m_window->traceset_info->before_traceset;
1056   g_assert(lttv_iattribute_find_by_path(attributes, "hooks/traceset/after",
1057       LTTV_POINTER, &value));
1058   *(value.v_pointer) = new_m_window->traceset_info->after_traceset;
1059   g_assert(lttv_iattribute_find_by_path(attributes, "hooks/trace/before",
1060       LTTV_POINTER, &value));
1061   *(value.v_pointer) = new_m_window->traceset_info->before_trace;
1062   g_assert(lttv_iattribute_find_by_path(attributes, "hooks/trace/after",
1063       LTTV_POINTER, &value));
1064   *(value.v_pointer) = new_m_window->traceset_info->after_trace;
1065   g_assert(lttv_iattribute_find_by_path(attributes, "hooks/tracefile/before",
1066       LTTV_POINTER, &value));
1067   *(value.v_pointer) = new_m_window->traceset_info->before_tracefile;
1068   g_assert(lttv_iattribute_find_by_path(attributes, "hooks/tracefile/after",
1069       LTTV_POINTER, &value));
1070   *(value.v_pointer) = new_m_window->traceset_info->after_tracefile;
1071   g_assert(lttv_iattribute_find_by_path(attributes, "hooks/event/before",
1072       LTTV_POINTER, &value));
1073   *(value.v_pointer) = new_m_window->traceset_info->before_event;
1074   g_assert(lttv_iattribute_find_by_path(attributes, "hooks/event/after",
1075       LTTV_POINTER, &value));
1076   *(value.v_pointer) = new_m_window->traceset_info->after_event;
1077
1078
1079   new_m_window->mwindow = new_window;
1080   new_m_window->tab = NULL;
1081   new_m_window->current_tab = NULL;
1082   new_m_window->attributes = LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
1083   if(parent){
1084     new_m_window->traceset_info->traceset =
1085         lttv_traceset_copy(parent->traceset_info->traceset);
1086
1087 //FIXME copy not implemented in lower level
1088     new_m_window->traceset_info->traceset_context =
1089         g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
1090     lttv_context_init(
1091         LTTV_TRACESET_CONTEXT(new_m_window->traceset_info->traceset_context),
1092         new_m_window->traceset_info->traceset);
1093   //new_m_window->traceset_context = parent->traceset_context;
1094     new_m_window->win_creation_data = parent->win_creation_data;
1095   }else{
1096     new_m_window->traceset_info->traceset = lttv_traceset_new();
1097
1098     /* Add the command line trace */
1099     if(g_init_trace != NULL && first_window)
1100       lttv_traceset_add(new_m_window->traceset_info->traceset, g_init_trace);
1101     /* NOTE : the context must be recreated if we change the traceset,
1102      * ie : adding/removing traces */
1103     new_m_window->traceset_info->traceset_context =
1104         g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
1105     lttv_context_init(
1106         LTTV_TRACESET_CONTEXT(new_m_window->traceset_info->traceset_context),
1107         new_m_window->traceset_info->traceset);
1108
1109     new_m_window->win_creation_data = win_creation_data;
1110   }
1111
1112   new_m_window->hash_menu_item = g_hash_table_new_full (g_str_hash, g_str_equal,
1113                                               main_window_destroy_hash_key,
1114                                               main_window_destroy_hash_data);
1115   new_m_window->hash_toolbar_item = g_hash_table_new_full (g_str_hash, g_str_equal,
1116                                               main_window_destroy_hash_key,
1117                                               main_window_destroy_hash_data);
1118
1119   insert_menu_toolbar_item(new_m_window, NULL);
1120
1121   g_object_set_data(G_OBJECT(new_window), "mainWindow", (gpointer)new_m_window);
1122
1123   //create a default tab
1124   notebook = (GtkNotebook *)lookup_widget(new_m_window->mwindow, "MNotebook");
1125   if(notebook == NULL){
1126     g_printf("Notebook does not exist\n");
1127     return;
1128   }
1129   //for now there is no name field in LttvTraceset structure
1130   //Use "Traceset" as the label for the default tab
1131   create_tab(new_m_window->mwindow, notebook,"Traceset");
1132
1133   g_object_set_data_full(
1134                         G_OBJECT(new_m_window->mwindow),
1135                         "Main_Window_Data",
1136                         new_m_window,
1137                         (GDestroyNotify)main_window_free);
1138
1139   g_win_count++;
1140 }
1141
1142 void tab_destructor(Tab * tab_instance)
1143 {
1144   if(tab_instance->attributes)
1145     g_object_unref(tab_instance->attributes);
1146
1147   if(tab_instance->mw->tab == tab_instance){
1148     tab_instance->mw->tab = tab_instance->next;
1149   }else{
1150     Tab * tmp1, *tmp = tab_instance->mw->tab;
1151     while(tmp != tab_instance){
1152       tmp1 = tmp;
1153       tmp = tmp->next;
1154     }
1155     tmp1->next = tab_instance->next;
1156   }
1157   g_free(tab_instance);
1158 }
1159
1160 void * create_tab(GtkWidget* parent, GtkNotebook * notebook, char * label)
1161 {
1162   GList * list;
1163   Tab * tmp_tab;
1164   MainWindow * mw_data;
1165   LttTime tmp_time;
1166
1167   mw_data = get_window_data_struct(parent);
1168   tmp_tab = mw_data->tab;
1169   while(tmp_tab && tmp_tab->next) tmp_tab = tmp_tab->next;
1170   if(!tmp_tab){
1171     mw_data->current_tab = NULL;
1172     tmp_tab = g_new(Tab,1);
1173     mw_data->tab = tmp_tab;
1174   }else{
1175     tmp_tab->next = g_new(Tab,1);
1176     tmp_tab = tmp_tab->next;
1177   }
1178   if(mw_data->current_tab){
1179  // Will have to read directly at the main window level, as we want
1180  // to be able to modify a traceset on the fly.
1181  //   tmp_tab->traceStartTime = mw_data->current_tab->traceStartTime;
1182  //   tmp_tab->traceEndTime   = mw_data->current_tab->traceEndTime;
1183     tmp_tab->time_window      = mw_data->current_tab->time_window;
1184     tmp_tab->current_time     = mw_data->current_tab->current_time;
1185   }else{
1186  // Will have to read directly at the main window level, as we want
1187  // to be able to modify a traceset on the fly.
1188   //  get_traceset_time_span(mw_data,&tmp_tab->traceStartTime, &tmp_tab->traceEndTime);
1189     tmp_tab->time_window.start_time   =
1190             LTTV_TRACESET_CONTEXT(mw_data->traceset_info->traceset_context)->Time_Span->startTime;
1191     if(DEFAULT_TIME_WIDTH_S <
1192               LTTV_TRACESET_CONTEXT(mw_data->traceset_info->traceset_context)->Time_Span->endTime.tv_sec)
1193       tmp_time.tv_sec = DEFAULT_TIME_WIDTH_S;
1194     else
1195       tmp_time.tv_sec =
1196               LTTV_TRACESET_CONTEXT(mw_data->traceset_info->traceset_context)->Time_Span->endTime.tv_sec;
1197     tmp_time.tv_nsec = 0;
1198     tmp_tab->time_window.time_width = tmp_time ;
1199     tmp_tab->current_time.tv_sec = tmp_time.tv_sec / 2;
1200     tmp_tab->current_time.tv_nsec = 0 ;
1201   }
1202   tmp_tab->attributes = LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
1203   //  mw_data->current_tab = tmp_tab;
1204   tmp_tab->custom = (GtkCustom*)gtk_custom_new();
1205   tmp_tab->custom->mw = mw_data;
1206   gtk_widget_show((GtkWidget*)tmp_tab->custom);
1207   tmp_tab->next = NULL;
1208   tmp_tab->mw   = mw_data;
1209
1210   tmp_tab->label = gtk_label_new (label);
1211   gtk_widget_show (tmp_tab->label);
1212
1213   g_object_set_data_full(
1214            G_OBJECT(tmp_tab->custom),
1215            "Tab_Info",
1216            tmp_tab,
1217            (GDestroyNotify)tab_destructor);
1218
1219   gtk_notebook_append_page(notebook, (GtkWidget*)tmp_tab->custom, tmp_tab->label);
1220   list = gtk_container_get_children(GTK_CONTAINER(notebook));
1221   gtk_notebook_set_current_page(notebook,g_list_length(list)-1);
1222 }
1223
1224 void remove_menu_item(gpointer main_win, gpointer user_data)
1225 {
1226   MainWindow * mw = (MainWindow *) main_win;
1227   lttv_menu_closure *menu_item = (lttv_menu_closure *)user_data;
1228   GtkWidget * tool_menu_title_menu, *insert_view;
1229
1230   tool_menu_title_menu = lookup_widget(mw->mwindow,"ToolMenuTitle_menu");
1231   insert_view = (GtkWidget*)g_hash_table_lookup(mw->hash_menu_item,
1232                                                 menu_item->menuText);
1233   if(insert_view){
1234     g_hash_table_remove(mw->hash_menu_item, menu_item->menuText);
1235     gtk_container_remove (GTK_CONTAINER (tool_menu_title_menu), insert_view);
1236   }
1237 }
1238
1239 void remove_toolbar_item(gpointer main_win, gpointer user_data)
1240 {
1241   MainWindow * mw = (MainWindow *) main_win;
1242   lttv_toolbar_closure *toolbar_item = (lttv_toolbar_closure *)user_data;
1243   GtkWidget * tool_menu_title_menu, *insert_view;
1244
1245
1246   tool_menu_title_menu = lookup_widget(mw->mwindow,"MToolbar2");
1247   insert_view = (GtkWidget*)g_hash_table_lookup(mw->hash_toolbar_item,
1248                                                 toolbar_item->tooltip);
1249   if(insert_view){
1250     g_hash_table_remove(mw->hash_toolbar_item, toolbar_item->tooltip);
1251     gtk_container_remove (GTK_CONTAINER (tool_menu_title_menu), insert_view);
1252   }
1253 }
1254
1255 /**
1256  * Remove menu and toolbar item when a module unloaded
1257  */
1258
1259 void main_window_remove_menu_item(lttv_constructor constructor)
1260 {
1261   int i;
1262   LttvMenus * menu;
1263   lttv_menu_closure *menu_item;
1264   LttvAttributeValue value;
1265   LttvIAttribute *attributes = LTTV_IATTRIBUTE(lttv_global_attributes());
1266
1267   g_assert(lttv_iattribute_find_by_path(attributes,
1268            "viewers/menu", LTTV_POINTER, &value));
1269   menu = (LttvMenus*)*(value.v_pointer);
1270
1271   if(menu){
1272     for(i=0;i<menu->len;i++){
1273       menu_item = &g_array_index(menu, lttv_menu_closure, i);
1274       if(menu_item->con != constructor) continue;
1275       if(g_main_window_list){
1276         g_slist_foreach(g_main_window_list, remove_menu_item, menu_item);
1277       }
1278       break;
1279     }
1280   }
1281
1282 }
1283
1284 void main_window_remove_toolbar_item(lttv_constructor constructor)
1285 {
1286   int i;
1287   LttvToolbars * toolbar;
1288   lttv_toolbar_closure *toolbar_item;
1289   LttvAttributeValue value;
1290   LttvIAttribute *attributes = LTTV_IATTRIBUTE(lttv_global_attributes());
1291
1292   g_assert(lttv_iattribute_find_by_path(attributes,
1293            "viewers/toolbar", LTTV_POINTER, &value));
1294   toolbar = (LttvToolbars*)*(value.v_pointer);
1295
1296   if(toolbar){
1297     for(i=0;i<toolbar->len;i++){
1298       toolbar_item = &g_array_index(toolbar, lttv_toolbar_closure, i);
1299       if(toolbar_item->con != constructor) continue;
1300       if(g_main_window_list){
1301         g_slist_foreach(g_main_window_list, remove_toolbar_item, toolbar_item);
1302       }
1303       break;
1304     }
1305   }
1306 }