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