ltt/branches/poly/lttv/modules/guiControlFlow/Process_List.c

   1
   2 #include <gtk/gtk.h>
   3 #include <glib.h>
   4 #include "Process_List.h"
   5
   6
   7 /*****************************************************************************
   8  *                       Methods to synchronize process list                 *
   9  *****************************************************************************/
  10
  11 /* Enumeration of the columns */
  12 enum
  13 {
  14         PROCESS_COLUMN,
  15         PID_COLUMN,
  16         BIRTH_S_COLUMN,
  17         BIRTH_NS_COLUMN,
  18         N_COLUMNS
  19 };
  20
  21
  22 gint process_sort_func  (       GtkTreeModel *model,
  23                                 GtkTreeIter *it_a,
  24                                 GtkTreeIter *it_b,
  25                                 gpointer user_data)
  26 {
  27         GValue a, b;
  28
  29         memset(&a, 0, sizeof(GValue));
  30         memset(&b, 0, sizeof(GValue));
  31
  32         /* Order by PID */
  33         gtk_tree_model_get_value(       model,
  34                                         it_a,
  35                                         PID_COLUMN,
  36                                         &a);
  37
  38         gtk_tree_model_get_value(       model,
  39                                         it_b,
  40                                         PID_COLUMN,
  41                                         &b);
  42
  43         if(G_VALUE_TYPE(&a) == G_TYPE_UINT
  44                 && G_VALUE_TYPE(&b) == G_TYPE_UINT )
  45         {
  46                 if(g_value_get_uint(&a) > g_value_get_uint(&b))
  47                 {
  48                         g_value_unset(&a);
  49                         g_value_unset(&b);
  50                         return 1;
  51                 }
  52                 if(g_value_get_uint(&a) < g_value_get_uint(&b))
  53                 {
  54                         g_value_unset(&a);
  55                         g_value_unset(&b);
  56                         return 0;
  57                 }
  58         }
  59
  60         g_value_unset(&a);
  61         g_value_unset(&b);
  62
  63
  64         /* Order by birth second */
  65         gtk_tree_model_get_value(       model,
  66                                         it_a,
  67                                         BIRTH_S_COLUMN,
  68                                         &a);
  69
  70         gtk_tree_model_get_value(       model,
  71                                         it_b,
  72                                         BIRTH_S_COLUMN,
  73                                         &b);
  74
  75
  76         if(G_VALUE_TYPE(&a) == G_TYPE_ULONG
  77                 && G_VALUE_TYPE(&b) == G_TYPE_ULONG )
  78         {
  79                 if(g_value_get_ulong(&a) > g_value_get_ulong(&b))
  80                 {
  81                         g_value_unset(&a);
  82                         g_value_unset(&b);
  83                         return 1;
  84                 }
  85                 if(g_value_get_ulong(&a) < g_value_get_ulong(&b))
  86                 {
  87                         g_value_unset(&a);
  88                         g_value_unset(&b);
  89                         return 0;
  90                 }
  91
  92         }
  93
  94         g_value_unset(&a);
  95         g_value_unset(&b);
  96
  97         /* Order by birth nanosecond */
  98         gtk_tree_model_get_value(       model,
  99                                         it_a,
 100                                         BIRTH_NS_COLUMN,
 101                                         &a);
 102
 103         gtk_tree_model_get_value(       model,
 104                                         it_b,
 105                                         BIRTH_NS_COLUMN,
 106                                         &b);
 107
 108
 109         if(G_VALUE_TYPE(&a) == G_TYPE_ULONG
 110                 && G_VALUE_TYPE(&b) == G_TYPE_ULONG )
 111         {
 112                 if(g_value_get_ulong(&a) > g_value_get_ulong(&b))
 113                 {
 114                         g_value_unset(&a);
 115                         g_value_unset(&b);
 116                         return 1;
 117                 }
 118                 // Final condition
 119                 //if(g_value_get_ulong(&a) < g_value_get_ulong(&b))
 120                 //{
 121                 //      g_value_unset(&a);
 122                 //      g_value_unset(&b);
 123                 //      return 0;
 124                 //}
 125
 126         }
 127
 128         g_value_unset(&a);
 129         g_value_unset(&b);
 130
 131         return 0;
 132
 133 }
 134
 135 guint hash_fct(gconstpointer key)
 136 {
 137         return ((ProcessInfo*)key)->pid;
 138 }
 139
 140 gboolean equ_fct(gconstpointer a, gconstpointer b)
 141 {
 142         if(((ProcessInfo*)a)->pid != ((ProcessInfo*)b)->pid)
 143                 return 0;
 144 //      g_critical("compare %u and %u",((ProcessInfo*)a)->pid,((ProcessInfo*)b)->pid);
 145         if(((ProcessInfo*)a)->birth.tv_sec != ((ProcessInfo*)b)->birth.tv_sec)
 146                 return 0;
 147 //      g_critical("compare %u and %u",((ProcessInfo*)a)->birth.tv_sec,((ProcessInfo*)b)->birth.tv_sec);
 148
 149         if(((ProcessInfo*)a)->birth.tv_nsec != ((ProcessInfo*)b)->birth.tv_nsec)
 150                 return 0;
 151 //      g_critical("compare %u and %u",((ProcessInfo*)a)->birth.tv_nsec,((ProcessInfo*)b)->birth.tv_nsec);
 152
 153         return 1;
 154 }
 155
 156 void Destroy_hash_key(gpointer key);
 157
 158 void Destroy_hash_data(gpointer data);
 159
 160
 161
 162
 163 ProcessList *ProcessList_construct(void)
 164 {
 165         GtkTreeViewColumn *column;
 166         GtkCellRenderer *renderer;
 167
 168         ProcessList* Process_List = g_new(ProcessList,1);
 169
 170         Process_List->Number_Of_Process = 0;
 171
 172         /* Create the Process list */
 173         Process_List->Store_M = gtk_list_store_new (    N_COLUMNS,
 174                                                         G_TYPE_STRING,
 175                                                         G_TYPE_UINT,
 176                                                         G_TYPE_ULONG,
 177                                                         G_TYPE_ULONG);
 178
 179
 180         Process_List->Process_List_VC =
 181                 gtk_tree_view_new_with_model
 182                 (GTK_TREE_MODEL (Process_List->Store_M));
 183
 184         g_object_unref (G_OBJECT (Process_List->Store_M));
 185
 186         gtk_tree_sortable_set_sort_func(
 187                         GTK_TREE_SORTABLE(Process_List->Store_M),
 188                         PID_COLUMN,
 189                         process_sort_func,
 190                         NULL,
 191                         NULL);
 192
 193         gtk_tree_sortable_set_sort_column_id(
 194                         GTK_TREE_SORTABLE(Process_List->Store_M),
 195                         PID_COLUMN,
 196                         GTK_SORT_ASCENDING);
 197
 198         Process_List->Process_Hash = g_hash_table_new_full(
 199                         hash_fct, equ_fct,
 200                         Destroy_hash_key, Destroy_hash_data
 201                         );
 202
 203
 204         gtk_tree_view_set_headers_visible(
 205                 GTK_TREE_VIEW(Process_List->Process_List_VC), FALSE);
 206
 207         /* Create a column, associating the "text" attribute of the
 208          * cell_renderer to the first column of the model */
 209         /* Columns alignment : 0.0 : Left    0.5 : Center   1.0 : Right */
 210         renderer = gtk_cell_renderer_text_new ();
 211         column = gtk_tree_view_column_new_with_attributes (     "Process",
 212                                                                 renderer,
 213                                                                 "text",
 214                                                                 PROCESS_COLUMN,
 215                                                                 NULL);
 216         gtk_tree_view_column_set_alignment (column, 0.0);
 217         gtk_tree_view_column_set_fixed_width (column, 45);
 218         gtk_tree_view_append_column (
 219                 GTK_TREE_VIEW (Process_List->Process_List_VC), column);
 220
 221         column = gtk_tree_view_column_new_with_attributes (     "PID",
 222                                                                 renderer,
 223                                                                 "text",
 224                                                                 PID_COLUMN,
 225                                                                 NULL);
 226         gtk_tree_view_append_column (
 227                 GTK_TREE_VIEW (Process_List->Process_List_VC), column);
 228
 229
 230         column = gtk_tree_view_column_new_with_attributes (     "Birth sec",
 231                                                                 renderer,
 232                                                                 "text",
 233                                                                 BIRTH_S_COLUMN,
 234                                                                 NULL);
 235         gtk_tree_view_append_column (
 236                 GTK_TREE_VIEW (Process_List->Process_List_VC), column);
 237
 238         //gtk_tree_view_column_set_visible(column, 0);
 239         //
 240         column = gtk_tree_view_column_new_with_attributes (     "Birth nsec",
 241                                                                 renderer,
 242                                                                 "text",
 243                                                                 BIRTH_NS_COLUMN,
 244                                                                 NULL);
 245         gtk_tree_view_append_column (
 246                 GTK_TREE_VIEW (Process_List->Process_List_VC), column);
 247
 248         //gtk_tree_view_column_set_visible(column, 0);
 249
 250         g_object_set_data_full(
 251                         G_OBJECT(Process_List->Process_List_VC),
 252                         "Process_List_Data",
 253                         Process_List,
 254                         (GDestroyNotify)ProcessList_destroy);
 255
 256         Process_List->Test_Process_Sent = 0;
 257
 258         return Process_List;
 259 }
 260 void ProcessList_destroy(ProcessList *Process_List)
 261 {
 262         g_hash_table_destroy(Process_List->Process_Hash);
 263         Process_List->Process_Hash = NULL;
 264
 265         g_free(Process_List);
 266 }
 267
 268 GtkWidget *ProcessList_getWidget(ProcessList *Process_List)
 269 {
 270         return Process_List->Process_List_VC;
 271 }
 272
 273
 274
 275 gint get_cell_height(GtkTreeView *TreeView)
 276 {
 277         gint height;
 278         GtkTreeViewColumn *Column = gtk_tree_view_get_column(TreeView, 0);
 279         GList *Render_List = gtk_tree_view_column_get_cell_renderers(Column);
 280         GtkCellRenderer *Renderer = g_list_first(Render_List)->data;
 281
 282         gtk_tree_view_column_cell_get_size(Column, NULL, NULL, NULL, NULL, &height);
 283         //g_critical("cell 0 height : %u",height);
 284
 285         return height;
 286 }
 287
 288 void Destroy_hash_key(gpointer key)
 289 {
 290         g_free(key);
 291 }
 292
 293 void Destroy_hash_data(gpointer data)
 294 {
 295         g_free(data);
 296 }
 297
 298 int ProcessList_add(    ProcessList *Process_List,
 299                         guint pid,
 300                         LttTime *birth,
 301                         guint *height)
 302 {
 303         GtkTreeIter iter ;
 304         ProcessInfo *Process_Info = g_new(ProcessInfo, 1);
 305         GtkTreeRowReference *RowRef;
 306
 307         Process_Info->pid = pid;
 308         Process_Info->birth = *birth;
 309
 310         /* Add a new row to the model */
 311         gtk_list_store_append ( Process_List->Store_M, &iter);
 312         //g_critical ( "iter before : %s", gtk_tree_path_to_string (
 313         //              gtk_tree_model_get_path (
 314         //                              GTK_TREE_MODEL(Process_List->Store_M),
 315         //                              &iter)));
 316         gtk_list_store_set (    Process_List->Store_M, &iter,
 317                                 PROCESS_COLUMN, "name",
 318                                 PID_COLUMN, pid,
 319                                 BIRTH_S_COLUMN, birth->tv_sec,
 320                                 BIRTH_NS_COLUMN, birth->tv_nsec,
 321                                 -1);
 322         RowRef = gtk_tree_row_reference_new (
 323                         GTK_TREE_MODEL(Process_List->Store_M),
 324                         gtk_tree_model_get_path(
 325                                 GTK_TREE_MODEL(Process_List->Store_M),
 326                                 &iter));
 327
 328         g_hash_table_insert(    Process_List->Process_Hash,
 329                                 (gpointer)Process_Info,
 330                                 (gpointer)RowRef);
 331
 332         //g_critical ( "iter after : %s", gtk_tree_path_to_string (
 333         //              gtk_tree_model_get_path (
 334         //                              GTK_TREE_MODEL(Process_List->Store_M),
 335         //                              &iter)));
 336         Process_List->Number_Of_Process++;
 337
 338         *height = get_cell_height(GTK_TREE_VIEW(Process_List->Process_List_VC))
 339                                 * Process_List->Number_Of_Process ;
 340
 341
 342         return 0;
 343
 344 }
 345
 346 int ProcessList_remove( ProcessList *Process_List,
 347                         guint pid,
 348                         LttTime *birth)
 349 {
 350         ProcessInfo Process_Info;
 351         gint *path_indices;
 352         GtkTreeRowReference *got_RowRef;
 353         GtkTreeIter iter;
 354
 355         Process_Info.pid = pid;
 356         Process_Info.birth = *birth;
 357
 358         if(got_RowRef =
 359                 (GtkTreeRowReference*)g_hash_table_lookup(
 360                                         Process_List->Process_Hash,
 361                                         &Process_Info))
 362         {
 363                 gtk_tree_model_get_iter (
 364                                 GTK_TREE_MODEL(Process_List->Store_M),
 365                                 &iter,
 366                                 gtk_tree_row_reference_get_path(
 367                                         (GtkTreeRowReference*)got_RowRef)
 368                                 );
 369
 370                 gtk_list_store_remove (Process_List->Store_M, &iter);
 371
 372                 g_hash_table_remove(Process_List->Process_Hash,
 373                                 &Process_Info);
 374
 375                 Process_List->Number_Of_Process--;
 376
 377                 return 0;
 378         } else {
 379                 return 1;
 380         }
 381 }
 382
 383
 384 guint ProcessList_get_height(ProcessList *Process_List)
 385 {
 386         return get_cell_height(GTK_TREE_VIEW(Process_List->Process_List_VC))
 387                                 * Process_List->Number_Of_Process ;
 388 }
 389
 390
 391 gint ProcessList_get_process_pixels(    ProcessList *Process_List,
 392                                         guint pid, LttTime *birth,
 393                                         guint *y,
 394                                         guint *height)
 395 {
 396         ProcessInfo Process_Info;
 397         gint *path_indices;
 398         GtkTreeRowReference *got_RowRef;
 399
 400         Process_Info.pid = pid;
 401         Process_Info.birth = *birth;
 402
 403         if(got_RowRef =
 404                 (GtkTreeRowReference*)g_hash_table_lookup(
 405                                         Process_List->Process_Hash,
 406                                         &Process_Info))
 407         {
 408                 path_indices =  gtk_tree_path_get_indices (
 409                                 gtk_tree_row_reference_get_path(
 410                                         (GtkTreeRowReference*)got_RowRef)
 411                                 );
 412
 413                 *height = get_cell_height(
 414                                 GTK_TREE_VIEW(Process_List->Process_List_VC));
 415                 *y = *height * path_indices[0];
 416
 417                 return 0;
 418         } else {
 419                 return 1;
 420         }
 421
 422
 423
 424 }