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