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