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