ltt/branches/poly/lttv/modules/guiEvents.c

   1 //*! \defgroup GuiEvents libGuiEvents: The GUI Events display plugin */
   2 /*\@{*/
   3
   4 /*! \file GuiEvents.c
   5  * \brief Graphical plugin for showing events.
   6  *
   7  * This plugin lists all the events contained in the current time interval
   8  * in a list.
   9  *
  10  * This plugin adds a Events Viewer functionnality to Linux TraceToolkit
  11  * GUI when this plugin is loaded. The init and destroy functions add the
  12  * viewer's insertion menu item and toolbar icon by calling gtkTraceSet's
  13  * API functions. Then, when a viewer's object is created, the constructor
  14  * creates ans register through API functions what is needed to interact
  15  * with the TraceSet window.
  16  *
  17  * Coding standard :
  18  * pm : parameter
  19  * l  : local
  20  * g  : global
  21  * s  : static
  22  * h  : hook
  23  *
  24  * Author : Karim Yaghmour
  25  *          Integrated to LTTng by Mathieu Desnoyers, June 2003
  26  */
  27
  28 #include <glib.h>
  29 #include <gmodule.h>
  30 #include <gtk/gtk.h>
  31 #include <gdk/gdk.h>
  32
  33 #include <lttv/module.h>
  34 //#include <lttv/gtkTraceSet.h>
  35 #include "mw_api.h"
  36 #include "gtktreeprivate.h"
  37
  38 #include "icons/hGuiEventsInsert.xpm"
  39
  40 /** Array containing instanced objects. Used when module is unloaded */
  41 static GSList *sEvent_Viewer_Data_List = NULL ;
  42
  43 typedef struct _EventViewerData {
  44
  45         /* Model containing list data */
  46   GtkListStore *Store_M;
  47
  48         GtkWidget *HBox_V;
  49         /* Widget to display the data in a columned list */
  50   GtkWidget *Tree_V;
  51   GtkAdjustment *VTree_Adjust_C ;
  52         GdkWindow *TreeWindow ;
  53
  54         /* Vertical scrollbar and it's adjustment */
  55         GtkWidget *VScroll_VC;
  56   GtkAdjustment *VAdjust_C ;
  57
  58         /* Selection handler */
  59         GtkTreeSelection *Select_C;
  60
  61         guint Visible_Events;
  62
  63 } EventViewerData ;
  64
  65 //! Event Viewer's constructor hook
  66 GtkWidget *hGuiEvents(GtkWidget *pmParentWindow);
  67 //! Event Viewer's constructor
  68 EventViewerData *GuiEvents(void);
  69 //! Event Viewer's destructor
  70 void GuiEvents_Destructor(EventViewerData *Event_Viewer_Data);
  71
  72 /* Prototype for selection handler callback */
  73 static void tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data);
  74 static void v_scroll_cb (GtkAdjustment *adjustment, gpointer data);
  75 static void Tree_V_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data);
  76 static void Tree_V_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data);
  77
  78
  79 void add_test_data(EventViewerData *Event_Viewer_Data);
  80
  81 /* TEST DATA, TO BE READ FROM THE TRACE */
  82 static int Number_Of_Events = 1000;
  83
  84 //FIXME: use the size of the widget to get number of rows.
  85 static int Number_Of_Rows = 50 ;
  86 //FIXME
  87 static int Cell_Height = 52;
  88
  89 /**
  90  * plugin's init function
  91  *
  92  * This function initializes the Event Viewer functionnality through the
  93  * gtkTraceSet API.
  94  */
  95 G_MODULE_EXPORT void init() {
  96         g_critical("GUI Event Viewer init()");
  97
  98         /* Register the toolbar insert button */
  99         //ToolbarItemReg(hGuiEventsInsert_xpm, "Insert Event Viewer", hGuiEvents);
 100
 101         /* Register the menu item insert entry */
 102         //MenuItemReg("/", "Insert Event Viewer", hGuiEvents);
 103 }
 104
 105 void destroy_walk(gpointer data, gpointer user_data)
 106 {
 107         GuiEvents_Destructor((EventViewerData*)data);
 108 }
 109
 110 /**
 111  * plugin's destroy function
 112  *
 113  * This function releases the memory reserved by the module and unregisters
 114  * everything that has been registered in the gtkTraceSet API.
 115  */
 116 G_MODULE_EXPORT void destroy() {
 117         int i;
 118
 119         EventViewerData *Event_Viewer_Data;
 120
 121         g_critical("GUI Event Viewer destroy()");
 122
 123         g_slist_foreach(sEvent_Viewer_Data_List, destroy_walk, NULL );
 124
 125         /* Unregister the toolbar insert button */
 126         //ToolbarItemUnreg(hGuiEvents);
 127
 128         /* Unregister the menu item insert entry */
 129         //MenuItemUnreg(hGuiEvents);
 130 }
 131
 132 /* Enumeration of the columns */
 133 enum
 134 {
 135         CPUID_COLUMN,
 136         EVENT_COLUMN,
 137         TIME_COLUMN,
 138         PID_COLUMN,
 139         ENTRY_LEN_COLUMN,
 140         EVENT_DESCR_COLUMN,
 141         N_COLUMNS
 142 };
 143
 144
 145 /**
 146  * Event Viewer's constructor hook
 147  *
 148  * This constructor is given as a parameter to the menuitem and toolbar button
 149  * registration. It creates the list.
 150  * @param pmParentWindow A pointer to the parent window.
 151  * @return The widget created.
 152  */
 153 GtkWidget *
 154 hGuiEvents(GtkWidget *pmParentWindow)
 155 {
 156         EventViewerData* Event_Viewer_Data = GuiEvents() ;
 157
 158         return Event_Viewer_Data->HBox_V ;
 159
 160 }
 161
 162 /**
 163  * Event Viewer's constructor
 164  *
 165  * This constructor is used to create EventViewerData data structure.
 166  * @return The Event viewer data created.
 167  */
 168 EventViewerData *
 169 GuiEvents(void)
 170 {
 171         GtkTreeViewColumn *column;
 172         GtkCellRenderer *renderer;
 173         EventViewerData* Event_Viewer_Data = g_new(EventViewerData,1) ;
 174
 175         /* Create a model for storing the data list */
 176   Event_Viewer_Data->Store_M = gtk_list_store_new (N_COLUMNS,       /* Total number of columns */
 177                                             G_TYPE_INT,      /* CPUID                  */
 178                                                                                                                                                                                 G_TYPE_STRING,   /* Event                   */
 179                                               G_TYPE_INT,      /* Time                    */
 180                                             G_TYPE_INT,      /* PID                     */
 181                                                   G_TYPE_INT,      /* Entry length            */
 182                                                 G_TYPE_STRING);  /* Event's description     */
 183
 184         /* Create the viewer widget for the columned list */
 185         Event_Viewer_Data->Tree_V = gtk_tree_view_new_with_model (GTK_TREE_MODEL (Event_Viewer_Data->Store_M));
 186
 187         g_signal_connect (G_OBJECT (Event_Viewer_Data->Tree_V), "size-allocate",
 188                           G_CALLBACK (Tree_V_size_allocate_cb),
 189                           Event_Viewer_Data);
 190                 g_signal_connect (G_OBJECT (Event_Viewer_Data->Tree_V), "size-request",
 191                           G_CALLBACK (Tree_V_size_request_cb),
 192                           Event_Viewer_Data);
 193
 194
 195 // Use on each column!
 196 //gtk_tree_view_column_set_sizing(Event_Viewer_Data->Tree_V, GTK_TREE_VIEW_COLUMN_FIXED);
 197
 198         /* The view now holds a reference.  We can get rid of our own
 199          * reference */
 200         g_object_unref (G_OBJECT (Event_Viewer_Data->Store_M));
 201
 202
 203   /* Create a column, associating the "text" attribute of the
 204    * cell_renderer to the first column of the model */
 205         /* Columns alignment : 0.0 : Left    0.5 : Center   1.0 : Right */
 206   renderer = gtk_cell_renderer_text_new ();
 207   column = gtk_tree_view_column_new_with_attributes ("CPUID",
 208                                                                                                                                                                                                                         renderer,
 209                                                       "text", CPUID_COLUMN,
 210                                                       NULL);
 211         gtk_tree_view_column_set_alignment (column, 0.0);
 212         gtk_tree_view_column_set_fixed_width (column, 45);
 213   gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
 214
 215   renderer = gtk_cell_renderer_text_new ();
 216   column = gtk_tree_view_column_new_with_attributes ("Event",
 217                                                                                                                                                                                                                         renderer,
 218                                                       "text", EVENT_COLUMN,
 219                                                       NULL);
 220         gtk_tree_view_column_set_alignment (column, 0.0);
 221         gtk_tree_view_column_set_fixed_width (column, 120);
 222   gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
 223
 224   renderer = gtk_cell_renderer_text_new ();
 225   column = gtk_tree_view_column_new_with_attributes ("Time",
 226                                                                                                                                                                                                                         renderer,
 227                                                       "text", TIME_COLUMN,
 228                                                       NULL);
 229         gtk_tree_view_column_set_alignment (column, 1.0);
 230         gtk_tree_view_column_set_fixed_width (column, 120);
 231   gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
 232
 233   renderer = gtk_cell_renderer_text_new ();
 234   column = gtk_tree_view_column_new_with_attributes ("PID",
 235                                                                                                                                                                                                                         renderer,
 236                                                       "text", PID_COLUMN,
 237                                                       NULL);
 238         gtk_tree_view_column_set_alignment (column, 1.0);
 239         gtk_tree_view_column_set_fixed_width (column, 45);
 240   gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
 241
 242   renderer = gtk_cell_renderer_text_new ();
 243   column = gtk_tree_view_column_new_with_attributes ("Entry Length",
 244                                                                                                                                                                                                                         renderer,
 245                                                       "text", ENTRY_LEN_COLUMN,
 246                                                       NULL);
 247         gtk_tree_view_column_set_alignment (column, 1.0);
 248         gtk_tree_view_column_set_fixed_width (column, 60);
 249   gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
 250
 251   renderer = gtk_cell_renderer_text_new ();
 252   column = gtk_tree_view_column_new_with_attributes ("Event's Description",
 253                                                                                                                                                                                                                         renderer,
 254                                                       "text", EVENT_DESCR_COLUMN,
 255                                                       NULL);
 256         gtk_tree_view_column_set_alignment (column, 0.0);
 257   gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
 258
 259
 260         /* Setup the selection handler */
 261         Event_Viewer_Data->Select_C = gtk_tree_view_get_selection (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V));
 262         gtk_tree_selection_set_mode (Event_Viewer_Data->Select_C, GTK_SELECTION_SINGLE);
 263         g_signal_connect (G_OBJECT (Event_Viewer_Data->Select_C), "changed",
 264                           G_CALLBACK (tree_selection_changed_cb),
 265                           NULL);
 266
 267   Event_Viewer_Data->HBox_V = gtk_hbox_new(0, 0);
 268   gtk_box_pack_start(GTK_BOX(Event_Viewer_Data->HBox_V), Event_Viewer_Data->Tree_V, TRUE, TRUE, 0);
 269
 270   /* Create vertical scrollbar and pack it */
 271   Event_Viewer_Data->VScroll_VC = gtk_vscrollbar_new(NULL);
 272   gtk_box_pack_start(GTK_BOX(Event_Viewer_Data->HBox_V), Event_Viewer_Data->VScroll_VC, FALSE, TRUE, 0);
 273
 274   /* Get the vertical scrollbar's adjustment */
 275   Event_Viewer_Data->VAdjust_C = gtk_range_get_adjustment(GTK_RANGE(Event_Viewer_Data->VScroll_VC));
 276         Event_Viewer_Data->VTree_Adjust_C = gtk_tree_view_get_vadjustment(
 277                                                                                                                         GTK_TREE_VIEW (Event_Viewer_Data->Tree_V));
 278
 279         g_signal_connect (G_OBJECT (Event_Viewer_Data->VAdjust_C), "value-changed",
 280                           G_CALLBACK (v_scroll_cb),
 281                           Event_Viewer_Data);
 282         /* Set the upper bound to the last event number */
 283         Event_Viewer_Data->VAdjust_C->lower = 0;
 284         Event_Viewer_Data->VAdjust_C->upper = Number_Of_Events;
 285         Event_Viewer_Data->VAdjust_C->value = 0;
 286         Event_Viewer_Data->VAdjust_C->step_increment = 1;
 287         Event_Viewer_Data->VAdjust_C->page_increment =
 288                                  Event_Viewer_Data->VTree_Adjust_C->upper;
 289         Event_Viewer_Data->VAdjust_C->page_size =
 290                                  Event_Viewer_Data->VTree_Adjust_C->upper;
 291         g_critical("value : %u",Event_Viewer_Data->VTree_Adjust_C->upper);
 292   /*  Raw event trace */
 293   gtk_widget_show(Event_Viewer_Data->HBox_V);
 294   gtk_widget_show(Event_Viewer_Data->Tree_V);
 295   gtk_widget_show(Event_Viewer_Data->VScroll_VC);
 296
 297         /* Add the object's information to the module's array */
 298   g_slist_append(sEvent_Viewer_Data_List, Event_Viewer_Data);
 299
 300         /* Test data */
 301         add_test_data(Event_Viewer_Data);
 302
 303         return Event_Viewer_Data;
 304 }
 305
 306 void v_scroll_cb (GtkAdjustment *adjustment, gpointer data)
 307 {
 308         g_critical("DEBUG : scroll signal");
 309
 310 }
 311
 312 gint get_cell_height(GtkTreeView *TreeView)
 313 {
 314         gint height, width;
 315         GtkTreeViewColumn *Column = gtk_tree_view_get_column(TreeView, 0);
 316         GList *Render_List = gtk_tree_view_column_get_cell_renderers(Column);
 317         GtkCellRenderer *Renderer = g_list_first(Render_List)->data;
 318
 319         gtk_cell_renderer_get_size(Renderer, GTK_WIDGET(TreeView),
 320                                                                                                                 NULL, NULL, NULL, &width, &height);
 321
 322         return height;
 323 }
 324
 325 void Tree_V_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data)
 326 {
 327         EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
 328         gint Cell_Height = get_cell_height(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V));
 329
 330         g_critical("size-allocate");
 331
 332         Event_Viewer_Data->Visible_Events = ( alloc->height -
 333                         TREE_VIEW_HEADER_HEIGHT (GTK_TREE_VIEW(Event_Viewer_Data->Tree_V)) )
 334                                 / Cell_Height ;
 335         g_critical("number of events shown : %u",Event_Viewer_Data->Visible_Events);
 336
 337         Event_Viewer_Data->VAdjust_C->page_increment =
 338                                  Event_Viewer_Data->Visible_Events;
 339         Event_Viewer_Data->VAdjust_C->page_size =
 340                                  Event_Viewer_Data->Visible_Events;
 341
 342 }
 343
 344 void Tree_V_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data)
 345 {
 346         gint h;
 347         EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
 348         gint Cell_Height = get_cell_height(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V));
 349
 350         g_critical("size-request");
 351
 352         h = Cell_Height + TREE_VIEW_HEADER_HEIGHT
 353                                                                                         (GTK_TREE_VIEW(Event_Viewer_Data->Tree_V));
 354         requisition->height = h;
 355
 356 }
 357
 358
 359 void add_test_data(EventViewerData *Event_Viewer_Data)
 360 {
 361         GtkTreeIter iter;
 362         int i;
 363
 364         for(i=0; i<10; i++)
 365         {
 366           /* Add a new row to the model */
 367                 gtk_list_store_append (Event_Viewer_Data->Store_M, &iter);
 368                 gtk_list_store_set (Event_Viewer_Data->Store_M, &iter,
 369                                                                                                 CPUID_COLUMN, 0,
 370                                                                                         EVENT_COLUMN, "event irq",
 371                                                                                           TIME_COLUMN, i,
 372                                                                                           PID_COLUMN, 100,
 373                                                                                           ENTRY_LEN_COLUMN, 17,
 374                                                                                           EVENT_DESCR_COLUMN, "Detailed information",
 375                                                                                                 -1);
 376         }
 377
 378 }
 379
 380
 381 void
 382 GuiEvents_Destructor(EventViewerData *Event_Viewer_Data)
 383 {
 384         guint index;
 385
 386         /* May already been done by GTK window closing */
 387         if(GTK_IS_WIDGET(Event_Viewer_Data->HBox_V))
 388                 gtk_widget_destroy(Event_Viewer_Data->HBox_V);
 389
 390         /* Destroy the Tree View */
 391         //gtk_widget_destroy(Event_Viewer_Data->Tree_V);
 392
 393   /*  Clear raw event list */
 394         //gtk_list_store_clear(Event_Viewer_Data->Store_M);
 395         //gtk_widget_destroy(GTK_WIDGET(Event_Viewer_Data->Store_M));
 396
 397         g_slist_remove(sEvent_Viewer_Data_List,Event_Viewer_Data);
 398 }
 399
 400 //FIXME : call hGuiEvents_Destructor for corresponding data upon widget destroy
 401
 402 static void
 403 tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data)
 404 {
 405         GtkTreeIter iter;
 406         GtkTreeModel *model;
 407         gchar *Event;
 408
 409         if (gtk_tree_selection_get_selected (selection, &model, &iter))
 410         {
 411                 gtk_tree_model_get (model, &iter, EVENT_COLUMN, &Event, -1);
 412
 413                 g_print ("Event selected :  %s\n", Event);
 414
 415                 g_free (Event);
 416         }
 417 }
 418
 419
 420
 421
 422 /* Imported code from LTT 0.9.6pre2 tracevisualizer */
 423 #ifdef DEBUG
 424
 425 /******************************************************************
 426  * Function :
 427  *    WDI_gtk_clist_set_last_row_data_full()
 428  * Description :
 429  *    Appends data to the last row of a GtkClist.
 430  * Parameters :
 431  * Return values :
 432  *    NONE.
 433  * History :
 434  *    J.H.D., 27/08/99, Initial typing.
 435  * Note :
 436  *    Based on gtk_clist_set_row_data_full() version 1.2.3.
 437  *    Much faster than using gtk_clist_set_row_data_full().
 438  ******************************************************************/
 439 static void WDI_gtk_clist_set_last_row_data_full(GtkCList*         pmClist,
 440                                           gpointer          pmData,
 441                                           GtkDestroyNotify  pmDestroy)
 442 {
 443   GtkCListRow *pClistRow;
 444
 445   g_return_if_fail (pmClist != NULL);
 446   g_return_if_fail (GTK_IS_CLIST (pmClist));
 447   g_return_if_fail (pmClist->row_list_end != NULL);
 448
 449   pClistRow = pmClist->row_list_end->data;
 450   pClistRow->data    = pmData;
 451   pClistRow->destroy = pmDestroy;
 452 }
 453
 454
 455 /******************************************************************
 456  * Function :
 457  *    SHRTEventSelect()
 458  * Description :
 459  * Parameters :
 460  * Return values :
 461  * History :
 462  * Note :
 463  ******************************************************************/
 464 static void SHRTEventSelect(GtkWidget*      pmCList,
 465                      gint            pmRow,
 466                      gint            pmColumn,
 467                      GdkEventButton* pmEvent,
 468                      gpointer        pmData)
 469 {
 470   systemView*  pSysView;        /* The system being displayed */
 471
 472   /* Do we have anything meaningfull */
 473   if((pSysView = (systemView*) pmData) == NULL)
 474     return;
 475
 476   /* Store the selected event */
 477   pSysView->Window->LastSelectedEvent = *(event*) gtk_clist_get_row_data(GTK_CLIST(pmCList), pmRow);
 478   pSysView->Window->EventSelected = TRUE;
 479 }
 480
 481 /******************************************************************
 482  * Function :
 483  *    SHRTEventButtonPress()
 484  * Description :
 485  * Parameters :
 486  * Return values :
 487  * History :
 488  * Note :
 489  ******************************************************************/
 490 static void SHRTEventButtonPress(GtkWidget*      pmCList,
 491                           GdkEventButton* pmEvent,
 492                           gpointer        pmData)
 493 {
 494   systemView*  pSysView;        /* The system being displayed */
 495   gint         row, column;     /* The clicked row and column */
 496
 497   /* Do we have anything meaningfull */
 498   if((pSysView = (systemView*) pmData) == NULL)
 499     return;
 500
 501   /* if we have a right-click event */
 502   if(pmEvent->button == 3)
 503     /* If we clicked on an item, get its row and column values */
 504     if(gtk_clist_get_selection_info(GTK_CLIST(pmCList), pmEvent->x, pmEvent->y, &row, &column))
 505       {
 506       /* Highlight the selected row */
 507       gtk_clist_select_row(GTK_CLIST(pmCList), row, column);
 508
 509       /* Store the selected event */
 510       pSysView->Window->LastSelectedEvent = *(event*) gtk_clist_get_row_data(GTK_CLIST(pmCList), row);
 511       pSysView->Window->EventSelected = TRUE;
 512
 513       /* Display the popup menu */
 514       gtk_menu_popup(GTK_MENU(pSysView->Window->RawEventPopup),
 515                      NULL, NULL, NULL, NULL,
 516                      pmEvent->button, GDK_CURRENT_TIME);
 517       }
 518 }
 519
 520
 521 /******************************************************************
 522  * Function :
 523  *    SHRTVAdjustValueChanged()
 524  * Description :
 525  * Parameters :
 526  * Return values :
 527  * History :
 528  * Note :
 529  ******************************************************************/
 530 static void SHRTVAdjustValueChanged(GtkAdjustment*  pmVAdjust,
 531                              gpointer        pmData)
 532 {
 533   event        lEvent;          /* Event used for searching */
 534   guint32      lPosition;       /* The position to scroll to */
 535   systemView*  pSysView;        /* The system being displayed */
 536
 537   /* Do we have anything meaningfull */
 538   if((pSysView = (systemView*) pmData) == NULL)
 539     return;
 540
 541   /* Is there an event database? */
 542   if(pSysView->EventDB == NULL)
 543     return;
 544
 545   /* Set the pointer to the first event */
 546   if(pSysView->EventDB->TraceStart == NULL)
 547     return;
 548
 549   /* Are we closer to the beginning? */
 550   if((pmVAdjust->value - (pmVAdjust->upper / 2)) < 0)
 551     {
 552     /* Set the navigation pointer to the beginning of the list */
 553     lEvent =  pSysView->EventDB->FirstEvent;
 554
 555     /* Calculate distance from beginning */
 556     lPosition = (guint32) pmVAdjust->value;
 557
 558     /* Find the event in the event database */
 559     while(lPosition > 0)
 560       {
 561       lPosition--;
 562       if(DBEventNext(pSysView->EventDB, &lEvent) != TRUE)
 563         break;
 564       }
 565     }
 566   else
 567     {
 568     /* Set the navigation pointer to the end of the list */
 569     lEvent = pSysView->EventDB->LastEvent;
 570
 571     /* Calculate distance from end */
 572     lPosition = (guint32) (pmVAdjust->upper - pmVAdjust->value);
 573
 574     /* Find the event in the event database */
 575     while(lPosition > 0)
 576       {
 577       lPosition--;
 578       if(DBEventPrev(pSysView->EventDB, &lEvent) != TRUE)
 579         break;
 580       }
 581     }
 582
 583   /* Fill the event list according to what was found */
 584   WDFillEventList(pSysView->Window->RTCList,
 585                   pSysView->EventDB,
 586                   pSysView->System,
 587                   &lEvent,
 588                   &(pSysView->Window->LastSelectedEvent));
 589 }
 590
 591
 592
 593 /******************************************************************
 594  * Function :
 595  *    WDConnectSignals()
 596  * Description :
 597  *    Attaches signal handlers to the window items.
 598  * Parameters :
 599  *    pmSysView, System view for which signals have to be connected
 600  * Return values :
 601  *    NONE
 602  * History :
 603  * Note :
 604  *    This function attaches a pointer to the main window during
 605  *    the connect. This means that the handlers will get a pointer
 606  *    to the window in the data argument.
 607  ******************************************************************/
 608 static void WDConnectSignals(systemView* pmSysView)
 609 {
 610   /* Raw event Popup menu */
 611   gtk_signal_connect(GTK_OBJECT(pmSysView->Window->RawGotoProcess),
 612                      "activate",
 613                      GTK_SIGNAL_FUNC(SHGotoProcAnalysis),
 614                      pmSysView);
 615   gtk_signal_connect(GTK_OBJECT(pmSysView->Window->RawViewEvent),
 616                      "activate",
 617                      GTK_SIGNAL_FUNC(SHViewEventInEG),
 618                      pmSysView);
 619
 620   /* Set event list callbacks */
 621   gtk_signal_connect(GTK_OBJECT(pmSysView->Window->RTCList),
 622                      "select_row",
 623                      GTK_SIGNAL_FUNC(SHRTEventSelect),
 624                      pmSysView);
 625   gtk_signal_connect(GTK_OBJECT(pmSysView->Window->RTCList),
 626                      "button-press-event",
 627                      GTK_SIGNAL_FUNC(SHRTEventButtonPress),
 628                      pmSysView);
 629   gtk_signal_connect(GTK_OBJECT(pmSysView->Window->RTVAdjust),
 630                      "value-changed",
 631                      GTK_SIGNAL_FUNC(SHRTVAdjustValueChanged),
 632                      pmSysView);
 633
 634
 635 }
 636
 637
 638 /******************************************************************
 639  * Function :
 640  *    WDFillEventList()
 641  * Description :
 642  *    Fills the window's event list using the trace database.
 643  * Parameters :
 644  *    pmList, The list to be filled.
 645  *    pmTraceDB, The database of events.
 646  *    pmSystem, The system to which this list belongs.
 647  *    pmEvent, Event from which we start drawing.
 648  *    pmSelectedEvent, Event selected if any.
 649  * Return values :
 650  *    NONE.
 651  * History :
 652  *    K.Y., 18/06/99, Initial typing.
 653  * Note :
 654  ******************************************************************/
 655 static void WDFillEventList(GtkWidget*  pmList,
 656                      db*         pmTraceDB,
 657                      systemInfo* pmSystem,
 658                      event*      pmEvent,
 659                      event*      pmSelectedEvent)
 660 {
 661   gint                i = 0;                              /* Generic index */
 662   event               lEvent;                             /* Generic event */
 663   gchar               lTimeStr[TIME_STR_LEN];             /* Time of event */
 664   static gchar*       lString[RTCLIST_NB_COLUMNS]={'\0'}; /* Strings describing event */
 665   process*            pProcess;                           /* Generic process pointer */
 666 #if SUPP_RTAI
 667   RTAItask*           pTask = NULL;                       /* Generic task pointer */
 668 #endif /* SUPP_RTAI */
 669   eventDescription    lEventDesc;                         /* Description of event */
 670
 671   /* Did we allocate space for strings */
 672   if(lString[0] == NULL)
 673     /* Allocate space for strings */
 674     for (i = 0;  i < RTCLIST_NB_COLUMNS - 1; i++)
 675       lString[i] = (char*) g_malloc(MW_DEFAULT_STRLEN);
 676
 677   /* Allocate space for description string */
 678   lString[RTCLIST_NB_COLUMNS - 1] = (char*) g_malloc(MW_LONG_STRLEN);
 679
 680   /* If no event was supplied, start at the beginning */
 681   if(pmEvent == NULL)
 682     lEvent = pmTraceDB->FirstEvent;
 683   else
 684     lEvent = *pmEvent;
 685
 686   /* Freeze and clear clist */
 687   gtk_clist_freeze(GTK_CLIST(pmList));
 688   gtk_clist_clear(GTK_CLIST(pmList));
 689
 690   /* Reset index */
 691   i = 0;
 692
 693   /* Go through the event list */
 694   do
 695     {
 696     /* Get the event description */
 697     DBEventDescription(pmTraceDB, &lEvent, TRUE, &lEventDesc);
 698
 699     /* Get the event's process */
 700     pProcess = DBEventProcess(pmTraceDB, &lEvent, pmSystem, FALSE);
 701
 702 #if SUPP_RTAI
 703     /* Does this trace contain RTAI information */
 704     if(pmTraceDB->SystemType == TRACE_SYS_TYPE_RTAI_LINUX)
 705       /* Get the RTAI task to which this event belongs */
 706       pTask = RTAIDBEventTask(pmTraceDB, &lEvent, pmSystem, FALSE);
 707 #endif /* SUPP_RTAI */
 708
 709     /* Set the event's entry in the list of raw events displayed */
 710     sRawEventsDisplayed[i] = lEvent;
 711
 712     /* Add text describing the event */
 713     /*  The CPU ID */
 714     if(pmTraceDB->LogCPUID == TRUE)
 715       snprintf(lString[0], MW_DEFAULT_STRLEN, "%d", lEventDesc.CPUID);
 716     else
 717       snprintf(lString[0], MW_DEFAULT_STRLEN, "0");
 718
 719     /*  The event ID */
 720     snprintf(lString[1], MW_DEFAULT_STRLEN, "%s", pmTraceDB->EventString(pmTraceDB, lEventDesc.ID, &lEvent));
 721
 722     /*  The event's time of occurence */
 723     DBFormatTimeInReadableString(lTimeStr,
 724                                  lEventDesc.Time.tv_sec,
 725                                  lEventDesc.Time.tv_usec);
 726     snprintf(lString[2], MW_DEFAULT_STRLEN, "%s", lTimeStr);
 727
 728     /* Is this an RT event */
 729     if(lEventDesc.ID <= TRACE_MAX)
 730       {
 731       /*  The PID of the process to which the event belongs */
 732       if(pProcess != NULL)
 733         snprintf(lString[3], MW_DEFAULT_STRLEN, "%d", pProcess->PID);
 734       else
 735         snprintf(lString[3], MW_DEFAULT_STRLEN, "N/A");
 736       }
 737 #if SUPP_RTAI
 738     else
 739       {
 740       /*  The TID of the task to which the event belongs */
 741       if(pTask != NULL)
 742         snprintf(lString[3], MW_DEFAULT_STRLEN, "RT:%d", pTask->TID);
 743       else
 744         snprintf(lString[3], MW_DEFAULT_STRLEN, "RT:N/A");
 745       }
 746 #endif /* SUPP_RTAI */
 747
 748     /*  The size of the entry */
 749     snprintf(lString[4], MW_DEFAULT_STRLEN, "%d", lEventDesc.Size);
 750
 751     /*  The string describing the event */
 752     snprintf(lString[5], MW_LONG_STRLEN, "%s", lEventDesc.String);
 753
 754     /* Insert the entry into the list */
 755     gtk_clist_append(GTK_CLIST(pmList), lString);
 756
 757     /* Set the row's data to point to the current event */
 758     WDI_gtk_clist_set_last_row_data_full(GTK_CLIST(pmList), (gpointer) &(sRawEventsDisplayed[i]), NULL);
 759
 760     /* Was this the last selected event */
 761     if(DBEventsEqual(lEvent, (*pmSelectedEvent)))
 762       gtk_clist_select_row(GTK_CLIST(pmList), i, 0);
 763
 764     /* Go to next row */
 765     i++;
 766     } while((DBEventNext(pmTraceDB, &lEvent) == TRUE) && (i < RTCLIST_NB_ROWS));
 767
 768   /* Resize the list's length */
 769   gtk_widget_queue_resize(pmList);
 770
 771   /* Thaw the clist */
 772   gtk_clist_thaw(GTK_CLIST(pmList));
 773 }
 774
 775 #endif //DEBUG
 776
 777 static void destroy_cb( GtkWidget *widget,
 778                                         gpointer   data )
 779 {
 780             gtk_main_quit ();
 781 }
 782
 783
 784
 785 int main(int argc, char **argv)
 786 {
 787         GtkWidget *Window;
 788         GtkWidget *ListViewer;
 789         GtkWidget *VBox_V;
 790         EventViewerData *Event_Viewer_Data;
 791
 792         /* Initialize i18n support */
 793   gtk_set_locale ();
 794
 795   /* Initialize the widget set */
 796   gtk_init (&argc, &argv);
 797
 798         init();
 799
 800   Window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 801         gtk_window_set_title (GTK_WINDOW (Window), ("Test Window"));
 802
 803         g_signal_connect (G_OBJECT (Window), "destroy",
 804                         G_CALLBACK (destroy_cb), NULL);
 805
 806
 807   VBox_V = gtk_vbox_new(0, 0);
 808         gtk_container_add (GTK_CONTAINER (Window), VBox_V);
 809
 810   ListViewer = hGuiEvents(Window);
 811   gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, TRUE, TRUE, 0);
 812
 813   //ListViewer = hGuiEvents(Window);
 814   //gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, FALSE, TRUE, 0);
 815
 816   gtk_widget_show (VBox_V);
 817         gtk_widget_show (Window);
 818
 819         gtk_main ();
 820
 821         g_critical("main loop finished");
 822
 823         //hGuiEvents_Destructor(ListViewer);
 824
 825         //g_critical("GuiEvents Destructor finished");
 826         destroy();
 827
 828         return 0;
 829 }
 830
 831
 832 /*\@}*/
 833