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         return Process_List;
 257 }
 258 void ProcessList_destroy(ProcessList *Process_List)
 259 {
 260         g_hash_table_destroy(Process_List->Process_Hash);
 261         Process_List->Process_Hash = NULL;
 262
 263         g_free(Process_List);
 264 }
 265
 266 GtkWidget *ProcessList_getWidget(ProcessList *Process_List)
 267 {
 268         return Process_List->Process_List_VC;
 269 }
 270
 271
 272
 273 gint get_cell_height(GtkTreeView *TreeView)
 274 {
 275         gint height;
 276         GtkTreeViewColumn *Column = gtk_tree_view_get_column(TreeView, 0);
 277         GList *Render_List = gtk_tree_view_column_get_cell_renderers(Column);
 278         GtkCellRenderer *Renderer = g_list_first(Render_List)->data;
 279
 280         gtk_tree_view_column_cell_get_size(Column, NULL, NULL, NULL, NULL, &height);
 281         g_critical("cell 0 height : %u",height);
 282
 283         return height;
 284 }
 285
 286 void Destroy_hash_key(gpointer key)
 287 {
 288         g_free(key);
 289 }
 290
 291 void Destroy_hash_data(gpointer data)
 292 {
 293         g_free(data);
 294 }
 295
 296 int ProcessList_add(    ProcessList *Process_List,
 297                         guint pid,
 298                         LttTime *birth,
 299                         guint *height)
 300 {
 301         GtkTreeIter iter ;
 302         ProcessInfo *Process_Info = g_new(ProcessInfo, 1);
 303         GtkTreeRowReference *RowRef;
 304
 305         Process_Info->pid = pid;
 306         Process_Info->birth = *birth;
 307
 308         /* Add a new row to the model */
 309         gtk_list_store_append ( Process_List->Store_M, &iter);
 310         g_critical ( "iter before : %s", gtk_tree_path_to_string (
 311                         gtk_tree_model_get_path (
 312                                         GTK_TREE_MODEL(Process_List->Store_M),
 313                                         &iter)));
 314         gtk_list_store_set (    Process_List->Store_M, &iter,
 315                                 PROCESS_COLUMN, "name",
 316                                 PID_COLUMN, pid,
 317                                 BIRTH_S_COLUMN, birth->tv_sec,
 318                                 BIRTH_NS_COLUMN, birth->tv_nsec,
 319                                 -1);
 320         RowRef = gtk_tree_row_reference_new (
 321                         GTK_TREE_MODEL(Process_List->Store_M),
 322                         gtk_tree_model_get_path(
 323                                 GTK_TREE_MODEL(Process_List->Store_M),
 324                                 &iter));
 325
 326         g_hash_table_insert(    Process_List->Process_Hash,
 327                                 (gpointer)Process_Info,
 328                                 (gpointer)RowRef);
 329
 330         g_critical ( "iter after : %s", gtk_tree_path_to_string (
 331                         gtk_tree_model_get_path (
 332                                         GTK_TREE_MODEL(Process_List->Store_M),
 333                                         &iter)));
 334         Process_List->Number_Of_Process++;
 335
 336         *height = get_cell_height(GTK_TREE_VIEW(Process_List->Process_List_VC))
 337                                 * Process_List->Number_Of_Process ;
 338
 339
 340         return 0;
 341
 342 }
 343
 344 int ProcessList_remove( ProcessList *Process_List,
 345                         guint pid,
 346                         LttTime *birth)
 347 {
 348         ProcessInfo Process_Info;
 349         gint *path_indices;
 350         GtkTreeRowReference *got_RowRef;
 351         GtkTreeIter iter;
 352
 353         Process_Info.pid = pid;
 354         Process_Info.birth = *birth;
 355
 356         if(got_RowRef =
 357                 (GtkTreeRowReference*)g_hash_table_lookup(
 358                                         Process_List->Process_Hash,
 359                                         &Process_Info))
 360         {
 361                 gtk_tree_model_get_iter (
 362                                 GTK_TREE_MODEL(Process_List->Store_M),
 363                                 &iter,
 364                                 gtk_tree_row_reference_get_path(
 365                                         (GtkTreeRowReference*)got_RowRef)
 366                                 );
 367
 368                 gtk_list_store_remove (Process_List->Store_M, &iter);
 369
 370                 g_hash_table_remove(Process_List->Process_Hash,
 371                                 &Process_Info);
 372
 373                 Process_List->Number_Of_Process--;
 374
 375                 return 0;
 376         } else {
 377                 return 1;
 378         }
 379 }
 380
 381
 382 guint ProcessList_get_height(ProcessList *Process_List)
 383 {
 384         return get_cell_height(GTK_TREE_VIEW(Process_List->Process_List_VC))
 385                                 * Process_List->Number_Of_Process ;
 386 }
 387
 388
 389 gint ProcessList_get_process_pixels(    ProcessList *Process_List,
 390                                         guint pid, LttTime *birth,
 391                                         guint *x,
 392                                         guint *height)
 393 {
 394         ProcessInfo Process_Info;
 395         gint *path_indices;
 396         GtkTreeRowReference *got_RowRef;
 397
 398         Process_Info.pid = pid;
 399         Process_Info.birth = *birth;
 400
 401         if(got_RowRef =
 402                 (GtkTreeRowReference*)g_hash_table_lookup(
 403                                         Process_List->Process_Hash,
 404                                         &Process_Info))
 405         {
 406                 path_indices =  gtk_tree_path_get_indices (
 407                                 gtk_tree_row_reference_get_path(
 408                                         (GtkTreeRowReference*)got_RowRef)
 409                                 );
 410
 411                 *height = get_cell_height(
 412                                 GTK_TREE_VIEW(Process_List->Process_List_VC));
 413                 *x = *height * path_indices[0];
 414
 415                 return 0;
 416         } else {
 417                 return 1;
 418         }
 419
 420
 421
 422 }