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 #include "Draw_Item.h"
   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_get_widget(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   //g_list_free(Render_List);
 283   gtk_tree_view_column_cell_get_size(Column, NULL, NULL, NULL, NULL, &height);
 284   //g_critical("cell 0 height : %u",height);
 285
 286   return height;
 287 }
 288
 289 void destroy_hash_key(gpointer key)
 290 {
 291   g_free(key);
 292 }
 293
 294 void destroy_hash_data(gpointer data)
 295 {
 296   g_free(data);
 297 }
 298
 299 int processlist_add(  ProcessList *process_list,
 300       guint pid,
 301       LttTime *birth,
 302       gchar *name,
 303       guint *height,
 304       HashedProcessData **pmhashed_process_data)
 305 {
 306   GtkTreeIter iter ;
 307   ProcessInfo *Process_Info = g_new(ProcessInfo, 1);
 308   HashedProcessData *hashed_process_data = g_new(HashedProcessData, 1);
 309   *pmhashed_process_data = hashed_process_data;
 310
 311   Process_Info->pid = pid;
 312   Process_Info->birth = *birth;
 313
 314   hashed_process_data->draw_context = g_new(DrawContext, 1);
 315   hashed_process_data->draw_context->drawable = NULL;
 316   hashed_process_data->draw_context->gc = NULL;
 317   hashed_process_data->draw_context->pango_layout = NULL;
 318   hashed_process_data->draw_context->current = g_new(DrawInfo,1);
 319   hashed_process_data->draw_context->current->over = g_new(ItemInfo,1);
 320   hashed_process_data->draw_context->current->over->x = -1;
 321   hashed_process_data->draw_context->current->over->y = -1;
 322   hashed_process_data->draw_context->current->middle = g_new(ItemInfo,1);
 323   hashed_process_data->draw_context->current->middle->x = -1;
 324   hashed_process_data->draw_context->current->middle->y = -1;
 325   hashed_process_data->draw_context->current->under = g_new(ItemInfo,1);
 326   hashed_process_data->draw_context->current->under->x = -1;
 327   hashed_process_data->draw_context->current->under->y = -1;
 328   hashed_process_data->draw_context->current->modify_over = g_new(ItemInfo,1);
 329   hashed_process_data->draw_context->current->modify_over->x = -1;
 330   hashed_process_data->draw_context->current->modify_over->y = -1;
 331   hashed_process_data->draw_context->current->modify_middle = g_new(ItemInfo,1);
 332   hashed_process_data->draw_context->current->modify_middle->x = -1;
 333   hashed_process_data->draw_context->current->modify_middle->y = -1;
 334   hashed_process_data->draw_context->current->modify_under = g_new(ItemInfo,1);
 335   hashed_process_data->draw_context->current->modify_under->x = -1;
 336   hashed_process_data->draw_context->current->modify_under->y = -1;
 337   hashed_process_data->draw_context->current->status = LTTV_STATE_UNNAMED;
 338   hashed_process_data->draw_context->previous = g_new(DrawInfo,1);
 339   hashed_process_data->draw_context->previous->over = g_new(ItemInfo,1);
 340   hashed_process_data->draw_context->previous->over->x = -1;
 341   hashed_process_data->draw_context->previous->over->y = -1;
 342   hashed_process_data->draw_context->previous->middle = g_new(ItemInfo,1);
 343   hashed_process_data->draw_context->previous->middle->x = -1;
 344   hashed_process_data->draw_context->previous->middle->y = -1;
 345   hashed_process_data->draw_context->previous->under = g_new(ItemInfo,1);
 346   hashed_process_data->draw_context->previous->under->x = -1;
 347   hashed_process_data->draw_context->previous->under->y = -1;
 348   hashed_process_data->draw_context->previous->modify_over = g_new(ItemInfo,1);
 349   hashed_process_data->draw_context->previous->modify_over->x = -1;
 350   hashed_process_data->draw_context->previous->modify_over->y = -1;
 351   hashed_process_data->draw_context->previous->modify_middle = g_new(ItemInfo,1);
 352   hashed_process_data->draw_context->previous->modify_middle->x = -1;
 353   hashed_process_data->draw_context->previous->modify_middle->y = -1;
 354   hashed_process_data->draw_context->previous->modify_under = g_new(ItemInfo,1);
 355   hashed_process_data->draw_context->previous->modify_under->x = -1;
 356   hashed_process_data->draw_context->previous->modify_under->y = -1;
 357   hashed_process_data->draw_context->previous->status = LTTV_STATE_UNNAMED;
 358
 359   /* Add a new row to the model */
 360   gtk_list_store_append ( process_list->Store_M, &iter);
 361   //g_critical ( "iter before : %s", gtk_tree_path_to_string (
 362   //    gtk_tree_model_get_path (
 363   //        GTK_TREE_MODEL(process_list->Store_M),
 364   //        &iter)));
 365   gtk_list_store_set (  process_list->Store_M, &iter,
 366         PROCESS_COLUMN, name,
 367         PID_COLUMN, pid,
 368         BIRTH_S_COLUMN, birth->tv_sec,
 369         BIRTH_NS_COLUMN, birth->tv_nsec,
 370         -1);
 371   hashed_process_data->RowRef = gtk_tree_row_reference_new (
 372       GTK_TREE_MODEL(process_list->Store_M),
 373       gtk_tree_model_get_path(
 374         GTK_TREE_MODEL(process_list->Store_M),
 375         &iter));
 376   g_hash_table_insert(  process_list->process_hash,
 377         (gpointer)Process_Info,
 378         (gpointer)hashed_process_data);
 379
 380   //g_critical ( "iter after : %s", gtk_tree_path_to_string (
 381   //    gtk_tree_model_get_path (
 382   //        GTK_TREE_MODEL(process_list->Store_M),
 383   //        &iter)));
 384   process_list->number_of_process++;
 385
 386   *height = get_cell_height(GTK_TREE_VIEW(process_list->process_list_VC))
 387         * process_list->number_of_process ;
 388
 389
 390   return 0;
 391
 392 }
 393
 394 int processlist_remove( ProcessList *process_list,
 395       guint pid,
 396       LttTime *birth)
 397 {
 398   ProcessInfo Process_Info;
 399   gint *path_indices;
 400   HashedProcessData *hashed_process_data;
 401   GtkTreeIter iter;
 402
 403   Process_Info.pid = pid;
 404   Process_Info.birth = *birth;
 405
 406
 407   if(hashed_process_data =
 408     (HashedProcessData*)g_hash_table_lookup(
 409           process_list->process_hash,
 410           &Process_Info))
 411   {
 412     gtk_tree_model_get_iter (
 413         GTK_TREE_MODEL(process_list->Store_M),
 414         &iter,
 415         gtk_tree_row_reference_get_path(
 416           (GtkTreeRowReference*)hashed_process_data->RowRef)
 417         );
 418
 419     gtk_list_store_remove (process_list->Store_M, &iter);
 420
 421     g_free(hashed_process_data->draw_context->previous->modify_under);
 422     g_free(hashed_process_data->draw_context->previous->modify_middle);
 423     g_free(hashed_process_data->draw_context->previous->modify_over);
 424     g_free(hashed_process_data->draw_context->previous->under);
 425     g_free(hashed_process_data->draw_context->previous->middle);
 426     g_free(hashed_process_data->draw_context->previous->over);
 427     g_free(hashed_process_data->draw_context->previous);
 428     g_free(hashed_process_data->draw_context->current->modify_under);
 429     g_free(hashed_process_data->draw_context->current->modify_middle);
 430     g_free(hashed_process_data->draw_context->current->modify_over);
 431     g_free(hashed_process_data->draw_context->current->under);
 432     g_free(hashed_process_data->draw_context->current->middle);
 433     g_free(hashed_process_data->draw_context->current->over);
 434     g_free(hashed_process_data->draw_context->current);
 435     g_free(hashed_process_data->draw_context);
 436     g_free(hashed_process_data);
 437
 438     g_hash_table_remove(process_list->process_hash,
 439         &Process_Info);
 440
 441     process_list->number_of_process--;
 442
 443     return 0;
 444   } else {
 445     return 1;
 446   }
 447 }
 448
 449
 450 guint processlist_get_height(ProcessList *process_list)
 451 {
 452   return get_cell_height(GTK_TREE_VIEW(process_list->process_list_VC))
 453         * process_list->number_of_process ;
 454 }
 455
 456
 457 gint processlist_get_process_pixels(  ProcessList *process_list,
 458           guint pid, LttTime *birth,
 459           guint *y,
 460           guint *height,
 461           HashedProcessData **pmhashed_process_data)
 462 {
 463   ProcessInfo Process_Info;
 464   gint *path_indices;
 465   GtkTreePath *tree_path;
 466   HashedProcessData *hashed_process_data = NULL;
 467
 468   Process_Info.pid = pid;
 469   Process_Info.birth = *birth;
 470
 471   if(hashed_process_data =
 472     (HashedProcessData*)g_hash_table_lookup(
 473           process_list->process_hash,
 474           &Process_Info))
 475   {
 476     tree_path = gtk_tree_row_reference_get_path(
 477                     hashed_process_data->RowRef);
 478     path_indices =  gtk_tree_path_get_indices (tree_path);
 479
 480     *height = get_cell_height(
 481         GTK_TREE_VIEW(process_list->process_list_VC));
 482     *y = *height * path_indices[0];
 483     *pmhashed_process_data = hashed_process_data;
 484     return 0;
 485   } else {
 486     *pmhashed_process_data = hashed_process_data;
 487     return 1;
 488   }
 489
 490 }
 491
 492
 493 gint processlist_get_pixels_from_data(  ProcessList *process_list,
 494           ProcessInfo *process_info,
 495           HashedProcessData *hashed_process_data,
 496           guint *y,
 497           guint *height)
 498 {
 499   gint *path_indices;
 500   GtkTreePath *tree_path;
 501
 502   tree_path = gtk_tree_row_reference_get_path(
 503                   hashed_process_data->RowRef);
 504   path_indices =  gtk_tree_path_get_indices (tree_path);
 505
 506   *height = get_cell_height(
 507       GTK_TREE_VIEW(process_list->process_list_VC));
 508   *y = *height * path_indices[0];
 509
 510   return 0;
 511
 512 }