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
  18 #define PATH_LENGTH     256
  19
  20 extern systemView * gSysView;
  21 extern LttvTracesetContext * gTracesetContext;
  22
  23 /** Array containing instanced objects. */
  24 extern GSList * Main_Window_List;
  25
  26 mainWindow * get_window_data_struct(GtkWidget * widget);
  27
  28 /* test part */
  29 void insertView(GtkWidget* widget, view_constructor constructor);
  30
  31 void
  32 on_textview1_grab_focus                     (GtkTextView     *text_view,
  33                                           gpointer         user_data)
  34 {
  35   GtkWidget * widget;
  36   GtkCustom * custom = (GtkCustom*)user_data;
  37   widget = gtk_widget_get_parent((GtkWidget*)text_view);
  38   widget = gtk_widget_get_parent(widget);
  39   gtk_custom_set_focus((GtkWidget*)custom, (gpointer)widget);
  40 }
  41
  42 void
  43 insertViewTest(GtkMenuItem *menuitem, gpointer user_data)
  44 {
  45   guint val = 20;
  46   insertView((GtkWidget*)menuitem, (view_constructor)user_data);
  47   //  selected_hook(&val);
  48 }
  49
  50 void
  51 on_insert_viewer_test_activate         (GtkMenuItem     *menuitem,
  52                                         gpointer         user_data)
  53 {
  54   GtkWidget *scrolledwindow1, *textview1, *label;
  55   static int count = 0;
  56   char str[64];
  57   GtkCustom * custom;
  58   GtkTextBuffer* buf;
  59
  60   mainWindow * mwData;
  61   mwData = get_window_data_struct((GtkWidget*)menuitem);
  62   if(!mwData->CurrentTab) return;
  63   custom = mwData->CurrentTab->custom;
  64
  65   sprintf(str,"label : %d",++count);
  66   scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
  67   gtk_widget_show (scrolledwindow1);
  68   label = gtk_label_new(str);
  69   gtk_widget_show(label);
  70
  71   gtk_custom_widget_add(custom, scrolledwindow1);
  72   gtk_widget_set_size_request ((GtkWidget*)scrolledwindow1, 800, 100);
  73
  74   textview1 = gtk_text_view_new ();
  75   gtk_widget_show (textview1);
  76   gtk_container_add (GTK_CONTAINER (scrolledwindow1), textview1);
  77   buf =  gtk_text_view_get_buffer((GtkTextView*)textview1);
  78   sprintf(str,"text view : %d",count);
  79   gtk_text_buffer_set_text(buf,str, -1);
  80
  81   g_signal_connect ((gpointer) textview1, "grab_focus",
  82                     G_CALLBACK (on_textview1_grab_focus), custom);
  83 }
  84
  85 /* end of test part */
  86
  87
  88 /* internal functions */
  89 void insertView(GtkWidget* widget, view_constructor constructor)
  90 {
  91   GtkCustom * custom;
  92   mainWindow * mwData;
  93   GtkWidget * viewer;
  94
  95   mwData = get_window_data_struct(widget);
  96   if(!mwData->CurrentTab) return;
  97   custom = mwData->CurrentTab->custom;
  98
  99   viewer = (GtkWidget*)constructor(mwData);
 100   if(viewer)
 101   {
 102     gtk_custom_widget_add(custom, viewer);
 103     // Added by MD
 104     //    g_object_unref(G_OBJECT(viewer));
 105   }
 106 }
 107
 108 void get_label_string (GtkWidget * text, gchar * label)
 109 {
 110   GtkEntry * entry = (GtkEntry*)text;
 111   if(strlen(gtk_entry_get_text(entry))!=0)
 112     strcpy(label,gtk_entry_get_text(entry));
 113 }
 114
 115 void get_label(GtkWindow * mw, gchar * str, gchar* dialogue_title, gchar * label_str)
 116 {
 117   GtkWidget * dialogue;
 118   GtkWidget * text;
 119   GtkWidget * label;
 120   gint id;
 121
 122   dialogue = gtk_dialog_new_with_buttons(dialogue_title,mw,
 123                                          GTK_DIALOG_MODAL,
 124                                          GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
 125                                          GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
 126                                          NULL);
 127
 128   label = gtk_label_new(label_str);
 129   gtk_widget_show(label);
 130
 131   text = gtk_entry_new();
 132   gtk_widget_show(text);
 133
 134   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), label,TRUE, TRUE,0);
 135   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), text,FALSE, FALSE,0);
 136
 137   id = gtk_dialog_run(GTK_DIALOG(dialogue));
 138   switch(id){
 139     case GTK_RESPONSE_ACCEPT:
 140       get_label_string(text,str);
 141       gtk_widget_destroy(dialogue);
 142       break;
 143     case GTK_RESPONSE_REJECT:
 144     default:
 145       gtk_widget_destroy(dialogue);
 146       break;
 147   }
 148 }
 149
 150 mainWindow * get_window_data_struct(GtkWidget * widget)
 151 {
 152   GtkWidget * mw;
 153   mainWindow * mwData;
 154
 155   mw = lookup_widget(widget, "MWindow");
 156   if(mw == NULL){
 157     g_printf("Main window does not exist\n");
 158     return;
 159   }
 160
 161   mwData = (mainWindow *) g_object_get_data(G_OBJECT(mw),"mainWindow");
 162   if(mwData == NULL){
 163     g_printf("Main window data does not exist\n");
 164     return;
 165   }
 166   return mwData;
 167 }
 168
 169 void createNewWindow(GtkWidget* widget, gpointer user_data, gboolean clone)
 170 {
 171   GtkWidget  * mw = NULL; /* Main window */
 172   systemView * sv = NULL; /* System view */
 173   systemView * newSv;     /* New system view displayed in the new window */
 174   GtkWidget  * newWindow; /* New generated main window */
 175   mainWindow * newMWindow;/* New main window structure */
 176
 177   //test
 178   int i;
 179   GtkWidget * ToolMenuTitle_menu, *insert_view, *pixmap;
 180   LttvMenus * menu;
 181   LttvToolbars * toolbar;
 182   lttv_menu_closure *menuItem;
 183   lttv_toolbar_closure *toolbarItem;
 184   LttvAttributeValue value;
 185   LttvIAttribute *attributes = LTTV_IATTRIBUTE(lttv_global_attributes());
 186   view_constructor constructor;
 187   GdkPixbuf *pixbuf;
 188   //end
 189
 190   mw = lookup_widget (widget, "MWindow");
 191   if(mw == NULL){
 192     g_printf("Can not find main window\n");
 193     return;
 194   }
 195
 196   sv = (systemView *)g_object_get_data(G_OBJECT(mw),"systemView");
 197   if(sv == NULL){
 198     g_printf("Can not find system view\n");
 199     return;
 200   }
 201
 202   newMWindow = g_new(mainWindow, 1);
 203
 204   /* Add the object's information to the module's array */
 205   Main_Window_List = g_slist_append(Main_Window_List, mw);
 206
 207   newWindow  = create_MWindow();
 208   gtk_widget_show (newWindow);
 209
 210
 211   newSv = g_new(systemView, 1);
 212   while(sv->Next) sv = sv->Next;
 213   sv->Next = newSv;
 214
 215   newSv->EventDB = NULL;
 216   newSv->SystemInfo = NULL;
 217   newSv->Options  = NULL;
 218   newSv->Next = NULL;
 219   newSv->Window = newMWindow;
 220
 221   newMWindow->MWindow = newWindow;
 222   newMWindow->Tab = NULL;
 223   newMWindow->CurrentTab = NULL;
 224   newMWindow->SystemView = newSv;
 225   newMWindow->Attributes = LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
 226   newMWindow->traceset_context = LTTV_TRACESET_CONTEXT(gTracesetContext);
 227   newMWindow->traceset = (LTTV_TRACESET_CONTEXT(gTracesetContext))->ts;
 228   g_object_ref(gTracesetContext);
 229
 230   //test yxx
 231   g_assert(lttv_iattribute_find_by_path(attributes,
 232            "viewers/menu", LTTV_POINTER, &value));
 233   menu = (LttvMenus*)*(value.v_pointer);
 234
 235   if(menu){
 236     for(i=0;i<menu->len;i++){
 237       menuItem = &g_array_index(menu, lttv_menu_closure, i);
 238       constructor = menuItem->con;
 239       ToolMenuTitle_menu = lookup_widget(newMWindow->MWindow,"ToolMenuTitle_menu");
 240       insert_view = gtk_menu_item_new_with_mnemonic (menuItem->menuText);
 241       gtk_widget_show (insert_view);
 242       gtk_container_add (GTK_CONTAINER (ToolMenuTitle_menu), insert_view);
 243       g_signal_connect ((gpointer) insert_view, "activate",
 244                         G_CALLBACK (insertViewTest),
 245                         constructor);
 246     }
 247   }
 248   g_assert(lttv_iattribute_find_by_path(attributes,
 249            "viewers/toolbar", LTTV_POINTER, &value));
 250   toolbar = (LttvToolbars*)*(value.v_pointer);
 251
 252   if(toolbar){
 253     for(i=0;i<toolbar->len;i++){
 254       toolbarItem = &g_array_index(toolbar, lttv_toolbar_closure, i);
 255       constructor = toolbarItem->con;
 256       ToolMenuTitle_menu = lookup_widget(newMWindow->MWindow,"MToolbar2");
 257       pixbuf = gdk_pixbuf_new_from_xpm_data ((const char**)toolbarItem->pixmap);
 258       pixmap = gtk_image_new_from_pixbuf(pixbuf);
 259       insert_view = gtk_toolbar_append_element (GTK_TOOLBAR (ToolMenuTitle_menu),
 260                                                 GTK_TOOLBAR_CHILD_BUTTON,
 261                                                 NULL,
 262                                                 "",
 263                                                 toolbarItem->tooltip, NULL,
 264                                                 pixmap, NULL, NULL);
 265       gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (ToolMenuTitle_menu)->children)->data))->label), TRUE);
 266       gtk_widget_show (insert_view);
 267       gtk_container_set_border_width (GTK_CONTAINER (insert_view), 1);
 268       g_signal_connect ((gpointer) insert_view, "clicked",G_CALLBACK (insertViewTest),constructor);
 269     }
 270   }
 271   //end
 272
 273   g_object_set_data(G_OBJECT(newWindow), "systemView", (gpointer)newSv);
 274   g_object_set_data(G_OBJECT(newWindow), "mainWindow", (gpointer)newMWindow);
 275
 276   if(clone){
 277     g_printf("Clone : use the same traceset\n");
 278   }else{
 279     g_printf("Empty : traceset is set to NULL\n");
 280   }
 281 }
 282
 283 void move_up_viewer(GtkWidget * widget, gpointer user_data)
 284 {
 285   mainWindow * mw = get_window_data_struct(widget);
 286   if(!mw->CurrentTab) return;
 287   gtk_custom_widget_move_up(mw->CurrentTab->custom);
 288 }
 289
 290 void move_down_viewer(GtkWidget * widget, gpointer user_data)
 291 {
 292   mainWindow * mw = get_window_data_struct(widget);
 293   if(!mw->CurrentTab) return;
 294   gtk_custom_widget_move_down(mw->CurrentTab->custom);
 295 }
 296
 297 void delete_viewer(GtkWidget * widget, gpointer user_data)
 298 {
 299   mainWindow * mw = get_window_data_struct(widget);
 300   if(!mw->CurrentTab) return;
 301   gtk_custom_widget_delete(mw->CurrentTab->custom);
 302 }
 303
 304 void open_traceset(GtkWidget * widget, gpointer user_data)
 305 {
 306   g_printf("Open a trace set\n");
 307 }
 308
 309 void add_trace(GtkWidget * widget, gpointer user_data)
 310 {
 311   g_printf("add a trace to a trace set\n");
 312 }
 313
 314 void remove_trace(GtkWidget * widget, gpointer user_data)
 315 {
 316   g_printf("remove a trace from a trace set\n");
 317 }
 318
 319 void save(GtkWidget * widget, gpointer user_data)
 320 {
 321   g_printf("Save\n");
 322 }
 323
 324 void save_as(GtkWidget * widget, gpointer user_data)
 325 {
 326   g_printf("Save as\n");
 327 }
 328
 329 void zoom_in(GtkWidget * widget, gpointer user_data)
 330 {
 331   g_printf("Zoom in\n");
 332 }
 333
 334 void zoom_out(GtkWidget * widget, gpointer user_data)
 335 {
 336   g_printf("Zoom out\n");
 337 }
 338
 339 void zoom_extended(GtkWidget * widget, gpointer user_data)
 340 {
 341   g_printf("Zoom extended\n");
 342 }
 343
 344 void go_to_time(GtkWidget * widget, gpointer user_data)
 345 {
 346   g_printf("Go to time\n");
 347 }
 348
 349 void show_time_frame(GtkWidget * widget, gpointer user_data)
 350 {
 351   g_printf("Show time frame\n");
 352 }
 353
 354
 355 /* callback function */
 356
 357 void
 358 on_empty_traceset_activate             (GtkMenuItem     *menuitem,
 359                                         gpointer         user_data)
 360 {
 361   createNewWindow((GtkWidget*)menuitem, user_data, FALSE);
 362 }
 363
 364
 365 void
 366 on_clone_traceset_activate             (GtkMenuItem     *menuitem,
 367                                         gpointer         user_data)
 368 {
 369   createNewWindow((GtkWidget*)menuitem, user_data, TRUE);
 370 }
 371
 372
 373 void
 374 on_tab_activate                        (GtkMenuItem     *menuitem,
 375                                         gpointer         user_data)
 376 {
 377   GList * list;
 378   gchar label[PATH_LENGTH];
 379
 380   tab * tmpTab;
 381   GtkWidget * pane;
 382   mainWindow * mwData;
 383   GtkNotebook * notebook = (GtkNotebook *)lookup_widget((GtkWidget*)menuitem, "MNotebook");
 384   if(notebook == NULL){
 385     g_printf("Notebook does not exist\n");
 386     return;
 387   }
 388
 389   mwData = get_window_data_struct((GtkWidget*)menuitem);
 390
 391   tmpTab = mwData->Tab;
 392   while(tmpTab && tmpTab->Next) tmpTab = tmpTab->Next;
 393   if(!tmpTab){
 394     mwData->CurrentTab = NULL;
 395     tmpTab = g_new(tab,1);
 396     mwData->Tab = tmpTab;
 397   }else{
 398     tmpTab->Next = g_new(tab,1);
 399     tmpTab = tmpTab->Next;
 400   }
 401   if(mwData->CurrentTab){
 402     tmpTab->traceStartTime = mwData->CurrentTab->traceStartTime;
 403     tmpTab->traceEndTime   = mwData->CurrentTab->traceEndTime;
 404     tmpTab->startTime      = mwData->CurrentTab->startTime;
 405     tmpTab->endTime        = mwData->CurrentTab->endTime;
 406     tmpTab->currentTime    = mwData->CurrentTab->currentTime;
 407   }else{
 408     getTracesetTimeSpan(mwData,&tmpTab->traceStartTime, &tmpTab->traceEndTime);
 409     tmpTab->startTime   = tmpTab->traceStartTime;
 410     tmpTab->endTime     = tmpTab->traceEndTime;
 411     tmpTab->currentTime = tmpTab->traceStartTime;
 412   }
 413   tmpTab->Attributes = LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
 414   //  mwData->CurrentTab = tmpTab;
 415   tmpTab->custom = (GtkCustom*)gtk_custom_new();
 416   tmpTab->custom->mw = mwData;
 417   gtk_widget_show((GtkWidget*)tmpTab->custom);
 418   tmpTab->Next = NULL;
 419
 420   strcpy(label,"Page");
 421   get_label((GtkWindow*)mwData->MWindow, label,"Get the name of the tab","Please input tab's name");
 422   tmpTab->label = gtk_label_new (label);
 423   gtk_widget_show (tmpTab->label);
 424
 425   gtk_notebook_append_page(notebook, (GtkWidget*)tmpTab->custom, tmpTab->label);
 426
 427   list = gtk_container_get_children(GTK_CONTAINER(notebook));
 428   gtk_notebook_set_current_page(notebook,g_list_length(list)-1);
 429 }
 430
 431
 432 void
 433 on_open_activate                       (GtkMenuItem     *menuitem,
 434                                         gpointer         user_data)
 435 {
 436   open_traceset((GtkWidget*)menuitem, user_data);
 437 }
 438
 439
 440 void
 441 on_close_activate                      (GtkMenuItem     *menuitem,
 442                                         gpointer         user_data)
 443 {
 444   g_printf("Close\n");
 445 }
 446
 447
 448 void
 449 on_close_tab_activate                  (GtkMenuItem     *menuitem,
 450                                         gpointer         user_data)
 451 {
 452   g_printf("Close tab\n");
 453 }
 454
 455
 456 void
 457 on_add_trace_activate                  (GtkMenuItem     *menuitem,
 458                                         gpointer         user_data)
 459 {
 460   add_trace((GtkWidget*)menuitem, user_data);
 461 }
 462
 463
 464 void
 465 on_remove_trace_activate               (GtkMenuItem     *menuitem,
 466                                         gpointer         user_data)
 467 {
 468   remove_trace((GtkWidget*)menuitem, user_data);
 469 }
 470
 471
 472 void
 473 on_save_activate                       (GtkMenuItem     *menuitem,
 474                                         gpointer         user_data)
 475 {
 476   save((GtkWidget*)menuitem, user_data);
 477 }
 478
 479
 480 void
 481 on_save_as_activate                    (GtkMenuItem     *menuitem,
 482                                         gpointer         user_data)
 483 {
 484   save_as((GtkWidget*)menuitem, user_data);
 485 }
 486
 487
 488 void
 489 on_quit_activate                       (GtkMenuItem     *menuitem,
 490                                         gpointer         user_data)
 491 {
 492   on_MWindow_destroy(GTK_OBJECT(menuitem), user_data);
 493 }
 494
 495
 496 void
 497 on_cut_activate                        (GtkMenuItem     *menuitem,
 498                                         gpointer         user_data)
 499 {
 500   g_printf("Cut\n");
 501 }
 502
 503
 504 void
 505 on_copy_activate                       (GtkMenuItem     *menuitem,
 506                                         gpointer         user_data)
 507 {
 508   g_printf("Copye\n");
 509 }
 510
 511
 512 void
 513 on_paste_activate                      (GtkMenuItem     *menuitem,
 514                                         gpointer         user_data)
 515 {
 516   g_printf("Paste\n");
 517 }
 518
 519
 520 void
 521 on_delete_activate                     (GtkMenuItem     *menuitem,
 522                                         gpointer         user_data)
 523 {
 524   g_printf("Delete\n");
 525 }
 526
 527
 528 void
 529 on_zoom_in_activate                    (GtkMenuItem     *menuitem,
 530                                         gpointer         user_data)
 531 {
 532    zoom_in((GtkWidget*)menuitem, user_data);
 533 }
 534
 535
 536 void
 537 on_zoom_out_activate                   (GtkMenuItem     *menuitem,
 538                                         gpointer         user_data)
 539 {
 540    zoom_out((GtkWidget*)menuitem, user_data);
 541 }
 542
 543
 544 void
 545 on_zoom_extended_activate              (GtkMenuItem     *menuitem,
 546                                         gpointer         user_data)
 547 {
 548    zoom_extended((GtkWidget*)menuitem, user_data);
 549 }
 550
 551
 552 void
 553 on_go_to_time_activate                 (GtkMenuItem     *menuitem,
 554                                         gpointer         user_data)
 555 {
 556    go_to_time((GtkWidget*)menuitem, user_data);
 557 }
 558
 559
 560 void
 561 on_show_time_frame_activate            (GtkMenuItem     *menuitem,
 562                                         gpointer         user_data)
 563 {
 564    show_time_frame((GtkWidget*)menuitem, user_data);
 565 }
 566
 567
 568 void
 569 on_move_viewer_up_activate             (GtkMenuItem     *menuitem,
 570                                         gpointer         user_data)
 571 {
 572   move_up_viewer((GtkWidget*)menuitem, user_data);
 573 }
 574
 575
 576 void
 577 on_move_viewer_down_activate           (GtkMenuItem     *menuitem,
 578                                         gpointer         user_data)
 579 {
 580   move_down_viewer((GtkWidget*)menuitem, user_data);
 581 }
 582
 583
 584 void
 585 on_remove_viewer_activate              (GtkMenuItem     *menuitem,
 586                                         gpointer         user_data)
 587 {
 588   delete_viewer((GtkWidget*)menuitem, user_data);
 589 }
 590
 591
 592 void
 593 on_load_module_activate                (GtkMenuItem     *menuitem,
 594                                         gpointer         user_data)
 595 {
 596   g_printf("Load module\n");
 597 }
 598
 599
 600 void
 601 on_unload_module_activate              (GtkMenuItem     *menuitem,
 602                                         gpointer         user_data)
 603 {
 604   g_printf("Unload module\n");
 605 }
 606
 607
 608 void
 609 on_add_module_search_path_activate     (GtkMenuItem     *menuitem,
 610                                         gpointer         user_data)
 611 {
 612   GtkDirSelection * fileSelector = (GtkDirSelection *)gtk_dir_selection_new("Select module path");
 613   char * dir;
 614   gint id;
 615
 616   gchar  str[PATH_LENGTH];
 617   mainWindow * mwData = get_window_data_struct((GtkWidget*)menuitem);
 618
 619   id = gtk_dialog_run(GTK_DIALOG(fileSelector));
 620   switch(id){
 621     case GTK_RESPONSE_ACCEPT:
 622     case GTK_RESPONSE_OK:
 623       dir = gtk_dir_selection_get_dir (fileSelector);
 624       lttv_module_path_add(dir);
 625     case GTK_RESPONSE_REJECT:
 626     case GTK_RESPONSE_CANCEL:
 627     default:
 628       gtk_widget_destroy((GtkWidget*)fileSelector);
 629       break;
 630   }
 631 }
 632
 633
 634 void
 635 on_color_activate                      (GtkMenuItem     *menuitem,
 636                                         gpointer         user_data)
 637 {
 638   g_printf("Color\n");
 639 }
 640
 641
 642 void
 643 on_filter_activate                     (GtkMenuItem     *menuitem,
 644                                         gpointer         user_data)
 645 {
 646   g_printf("Filter\n");
 647 }
 648
 649
 650 void
 651 on_save_configuration_activate         (GtkMenuItem     *menuitem,
 652                                         gpointer         user_data)
 653 {
 654   g_printf("Save configuration\n");
 655 }
 656
 657
 658 void
 659 on_content_activate                    (GtkMenuItem     *menuitem,
 660                                         gpointer         user_data)
 661 {
 662   g_printf("Content\n");
 663 }
 664
 665
 666 void
 667 on_about_activate                      (GtkMenuItem     *menuitem,
 668                                         gpointer         user_data)
 669 {
 670   g_printf("About...\n");
 671 }
 672
 673
 674 void
 675 on_button_new_clicked                  (GtkButton       *button,
 676                                         gpointer         user_data)
 677 {
 678   createNewWindow((GtkWidget*)button, user_data, FALSE);
 679 }
 680
 681
 682 void
 683 on_button_open_clicked                 (GtkButton       *button,
 684                                         gpointer         user_data)
 685 {
 686   open_traceset((GtkWidget*)button, user_data);
 687 }
 688
 689
 690 void
 691 on_button_add_trace_clicked            (GtkButton       *button,
 692                                         gpointer         user_data)
 693 {
 694   add_trace((GtkWidget*)button, user_data);
 695 }
 696
 697
 698 void
 699 on_button_remove_trace_clicked         (GtkButton       *button,
 700                                         gpointer         user_data)
 701 {
 702   remove_trace((GtkWidget*)button, user_data);
 703 }
 704
 705
 706 void
 707 on_button_save_clicked                 (GtkButton       *button,
 708                                         gpointer         user_data)
 709 {
 710   save((GtkWidget*)button, user_data);
 711 }
 712
 713
 714 void
 715 on_button_save_as_clicked              (GtkButton       *button,
 716                                         gpointer         user_data)
 717 {
 718   save_as((GtkWidget*)button, user_data);
 719 }
 720
 721
 722 void
 723 on_button_zoom_in_clicked              (GtkButton       *button,
 724                                         gpointer         user_data)
 725 {
 726    zoom_in((GtkWidget*)button, user_data);
 727 }
 728
 729
 730 void
 731 on_button_zoom_out_clicked             (GtkButton       *button,
 732                                         gpointer         user_data)
 733 {
 734    zoom_out((GtkWidget*)button, user_data);
 735 }
 736
 737
 738 void
 739 on_button_zoom_extended_clicked        (GtkButton       *button,
 740                                         gpointer         user_data)
 741 {
 742    zoom_extended((GtkWidget*)button, user_data);
 743 }
 744
 745
 746 void
 747 on_button_go_to_time_clicked           (GtkButton       *button,
 748                                         gpointer         user_data)
 749 {
 750    go_to_time((GtkWidget*)button, user_data);
 751 }
 752
 753
 754 void
 755 on_button_show_time_frame_clicked      (GtkButton       *button,
 756                                         gpointer         user_data)
 757 {
 758    show_time_frame((GtkWidget*)button, user_data);
 759 }
 760
 761
 762 void
 763 on_button_move_up_clicked              (GtkButton       *button,
 764                                         gpointer         user_data)
 765 {
 766   move_up_viewer((GtkWidget*)button, user_data);
 767 }
 768
 769
 770 void
 771 on_button_move_down_clicked            (GtkButton       *button,
 772                                         gpointer         user_data)
 773 {
 774   move_down_viewer((GtkWidget*)button, user_data);
 775 }
 776
 777
 778 void
 779 on_button_delete_viewer_clicked        (GtkButton       *button,
 780                                         gpointer         user_data)
 781 {
 782   delete_viewer((GtkWidget*)button, user_data);
 783 }
 784
 785 void
 786 on_MWindow_destroy                     (GtkObject       *object,
 787                                         gpointer         user_data)
 788 {
 789   systemView * sv = gSysView;
 790   gint count = 0;
 791   while(sv->Next){
 792     g_printf("There are : %d windows\n",++count);
 793     sv = sv->Next;
 794   }
 795   g_printf("There are : %d windows\n",++count);
 796
 797   gtk_main_quit ();
 798
 799 }
 800
 801
 802 void
 803 on_MNotebook_switch_page               (GtkNotebook     *notebook,
 804                                         GtkNotebookPage *page,
 805                                         guint            page_num,
 806                                         gpointer         user_data)
 807 {
 808   mainWindow * mw = get_window_data_struct((GtkWidget*)notebook);
 809   tab * Tab = mw->Tab;
 810
 811   while(page_num){
 812     Tab = Tab->Next;
 813     page_num--;
 814   }
 815   mw->CurrentTab = Tab;
 816 }
 817