[lttv.git] / ltt / branches / poly / lttv / modules / gui / controlflow / processlist.c

/* This file is part of the Linux Trace Toolkit viewer
 * Copyright (C) 2003-2004 Mathieu Desnoyers
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, 
 * MA 02111-1307, USA.
 */

#include <gtk/gtk.h>
#include <glib.h>

#include "processlist.h"
#include "drawitem.h"

#define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format)
#define g_debug(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format)


/*****************************************************************************
 *                       Methods to synchronize process list                 *
 *****************************************************************************/

/* Enumeration of the columns */
enum
{
  PROCESS_COLUMN,
  PID_COLUMN,
  BIRTH_S_COLUMN,
  BIRTH_NS_COLUMN,
  TRACE_COLUMN,
  N_COLUMNS
};


gint process_sort_func  ( GtkTreeModel *model,
        GtkTreeIter *it_a,
        GtkTreeIter *it_b,
        gpointer user_data)
{
  GValue a, b;

  memset(&a, 0, sizeof(GValue));
  memset(&b, 0, sizeof(GValue));
  
  /* Order by PID */
  gtk_tree_model_get_value( model,
          it_a,
          PID_COLUMN,
          &a);

  gtk_tree_model_get_value( model,
          it_b,
          PID_COLUMN,
          &b);

  if(G_VALUE_TYPE(&a) == G_TYPE_UINT
    && G_VALUE_TYPE(&b) == G_TYPE_UINT )
  {
    if(g_value_get_uint(&a) > g_value_get_uint(&b))
    {
      g_value_unset(&a);
      g_value_unset(&b);
      return 1;
    }
    if(g_value_get_uint(&a) < g_value_get_uint(&b))
    {
      g_value_unset(&a);
      g_value_unset(&b);
      return 0;
    }
  }

  g_value_unset(&a);
  g_value_unset(&b);


  /* Order by birth second */
  gtk_tree_model_get_value( model,
          it_a,
          BIRTH_S_COLUMN,
          &a);

  gtk_tree_model_get_value( model,
          it_b,
          BIRTH_S_COLUMN,
          &b);


  if(G_VALUE_TYPE(&a) == G_TYPE_ULONG
    && G_VALUE_TYPE(&b) == G_TYPE_ULONG )
  {
    if(g_value_get_ulong(&a) > g_value_get_ulong(&b))
    {
      g_value_unset(&a);
      g_value_unset(&b);
      return 1;
    }
    if(g_value_get_ulong(&a) < g_value_get_ulong(&b))
    {
      g_value_unset(&a);
      g_value_unset(&b);
      return 0;
    }

  }

  g_value_unset(&a);
  g_value_unset(&b);

  /* Order by birth nanosecond */
  gtk_tree_model_get_value( model,
          it_a,
          BIRTH_NS_COLUMN,
          &a);

  gtk_tree_model_get_value( model,
          it_b,
          BIRTH_NS_COLUMN,
          &b);


  if(G_VALUE_TYPE(&a) == G_TYPE_ULONG
    && G_VALUE_TYPE(&b) == G_TYPE_ULONG )
  {
    if(g_value_get_ulong(&a) > g_value_get_ulong(&b))
    {
      g_value_unset(&a);
      g_value_unset(&b);
      return 1;
    }
    // Final condition
    //if(g_value_get_ulong(&a) < g_value_get_ulong(&b))
    //{
    //  g_value_unset(&a);
    //  g_value_unset(&b);
    //  return 0;
    //}

  }
  
  g_value_unset(&a);
  g_value_unset(&b);

  /* Order by trace_num */
  gtk_tree_model_get_value( model,
          it_a,
          TRACE_COLUMN,
          &a);

  gtk_tree_model_get_value( model,
          it_b,
          TRACE_COLUMN,
          &b);

  if(G_VALUE_TYPE(&a) == G_TYPE_ULONG
    && G_VALUE_TYPE(&b) == G_TYPE_ULONG )
  {
    if(g_value_get_ulong(&a) > g_value_get_ulong(&b))
    {
      g_value_unset(&a);
      g_value_unset(&b);
      return 1;
    }
    if(g_value_get_ulong(&a) < g_value_get_ulong(&b))
    {
      g_value_unset(&a);
      g_value_unset(&b);
      return 0;
    }

  }


  return 0;

}

guint hash_fct(gconstpointer key)
{
  return ((ProcessInfo*)key)->pid;
}

gboolean equ_fct(gconstpointer a, gconstpointer b)
{
  if(((ProcessInfo*)a)->pid != ((ProcessInfo*)b)->pid)
    return 0;
//  g_critical("compare %u and %u",((ProcessInfo*)a)->pid,((ProcessInfo*)b)->pid);
  if(((ProcessInfo*)a)->birth.tv_sec != ((ProcessInfo*)b)->birth.tv_sec)
    return 0;
//  g_critical("compare %u and %u",((ProcessInfo*)a)->birth.tv_sec,((ProcessInfo*)b)->birth.tv_sec);

  if(((ProcessInfo*)a)->birth.tv_nsec != ((ProcessInfo*)b)->birth.tv_nsec)
    return 0;
//  g_critical("compare %u and %u",((ProcessInfo*)a)->birth.tv_nsec,((ProcessInfo*)b)->birth.tv_nsec);

  if(((ProcessInfo*)a)->trace_num != ((ProcessInfo*)b)->trace_num)
    return 0;

  return 1;
}

void destroy_hash_key(gpointer key);

void destroy_hash_data(gpointer data);


ProcessList *processlist_construct(void)
{
  GtkTreeViewColumn *column;
  GtkCellRenderer *renderer;
  
  ProcessList* process_list = g_new(ProcessList,1);
  
  process_list->number_of_process = 0;

  /* Create the Process list */
  process_list->list_store = gtk_list_store_new (  N_COLUMNS,
              G_TYPE_STRING,
              G_TYPE_UINT,
              G_TYPE_ULONG,
              G_TYPE_ULONG,
              G_TYPE_ULONG);


  process_list->process_list_widget = 
    gtk_tree_view_new_with_model
    (GTK_TREE_MODEL (process_list->list_store));
  g_object_unref (G_OBJECT (process_list->list_store));

  gtk_tree_sortable_set_sort_func(
      GTK_TREE_SORTABLE(process_list->list_store),
      PID_COLUMN,
      process_sort_func,
      NULL,
      NULL);
  
  gtk_tree_sortable_set_sort_column_id(
      GTK_TREE_SORTABLE(process_list->list_store),
      PID_COLUMN,
      GTK_SORT_ASCENDING);
  
  process_list->process_hash = g_hash_table_new_full(
      hash_fct, equ_fct,
      destroy_hash_key, destroy_hash_data
      );
  
  
  gtk_tree_view_set_headers_visible(
    GTK_TREE_VIEW(process_list->process_list_widget), TRUE);

  /* Create a column, associating the "text" attribute of the
   * cell_renderer to the first column of the model */
  /* Columns alignment : 0.0 : Left    0.5 : Center   1.0 : Right */
  renderer = gtk_cell_renderer_text_new ();
  column = gtk_tree_view_column_new_with_attributes ( "Process",
                renderer,
                "text",
                PROCESS_COLUMN,
                NULL);
  gtk_tree_view_column_set_alignment (column, 0.0);
  gtk_tree_view_column_set_fixed_width (column, 45);
  gtk_tree_view_append_column (
    GTK_TREE_VIEW (process_list->process_list_widget), column);

  column = gtk_tree_view_column_new_with_attributes ( "PID",
                renderer,
                "text",
                PID_COLUMN,
                NULL);
  gtk_tree_view_append_column (
    GTK_TREE_VIEW (process_list->process_list_widget), column);


  column = gtk_tree_view_column_new_with_attributes ( "Birth sec",
                renderer,
                "text",
                BIRTH_S_COLUMN,
                NULL);
  gtk_tree_view_append_column (
    GTK_TREE_VIEW (process_list->process_list_widget), column);

  //gtk_tree_view_column_set_visible(column, 0);
  //
  column = gtk_tree_view_column_new_with_attributes ( "Birth nsec",
                renderer,
                "text",
                BIRTH_NS_COLUMN,
                NULL);
  gtk_tree_view_append_column (
    GTK_TREE_VIEW (process_list->process_list_widget), column);

  column = gtk_tree_view_column_new_with_attributes ( "TRACE",
                renderer,
                "text",
                TRACE_COLUMN,
                NULL);
  gtk_tree_view_append_column (
    GTK_TREE_VIEW (process_list->process_list_widget), column);


  //gtk_tree_view_column_set_visible(column, 0);
  
  g_object_set_data_full(
      G_OBJECT(process_list->process_list_widget),
      "process_list_Data",
      process_list,
      (GDestroyNotify)processlist_destroy);

  return process_list;
}
void processlist_destroy(ProcessList *process_list)
{
  g_info("processlist_destroy %p", process_list);
  g_hash_table_destroy(process_list->process_hash);
  process_list->process_hash = NULL;

  g_free(process_list);
  g_info("processlist_destroy end");
}

GtkWidget *processlist_get_widget(ProcessList *process_list)
{
  return process_list->process_list_widget;
}


gint get_cell_height(GtkTreeView *tree_view)
{
  gint height;
  GtkTreeViewColumn *Column = gtk_tree_view_get_column(tree_view, 0);
  //GList *Render_List = gtk_tree_view_column_get_cell_renderers(Column);
  //GtkCellRenderer *Renderer = g_list_first(Render_List)->data;
  
  //g_list_free(Render_List);
  gtk_tree_view_column_cell_get_size(Column, NULL, NULL, NULL, NULL, &height);
  //g_critical("cell 0 height : %u",height);
  
  return height;
}

void destroy_hash_key(gpointer key)
{
  g_free(key);
}

void destroy_hash_data(gpointer data)
{
  g_free(data);
}

int processlist_add(  ProcessList *process_list,
      guint pid,
      LttTime *birth,
      guint trace_num,
      const gchar *name,
      guint *height,
      HashedProcessData **pm_hashed_process_data)
{
  GtkTreeIter iter ;
  ProcessInfo *Process_Info = g_new(ProcessInfo, 1);
  HashedProcessData *hashed_process_data = g_new(HashedProcessData, 1);
  *pm_hashed_process_data = hashed_process_data;
  
  Process_Info->pid = pid;
  Process_Info->birth = *birth;
  Process_Info->trace_num = trace_num;
  
  hashed_process_data->draw_context = g_new(DrawContext, 1);
  hashed_process_data->draw_context->drawable = NULL;
  hashed_process_data->draw_context->gc = NULL;
  hashed_process_data->draw_context->pango_layout = NULL;
  hashed_process_data->draw_context->current = g_new(DrawInfo,1);
  hashed_process_data->draw_context->current->over = g_new(ItemInfo,1);
  hashed_process_data->draw_context->current->over->x = -1;
  hashed_process_data->draw_context->current->over->y = -1;
  hashed_process_data->draw_context->current->middle = g_new(ItemInfo,1);
  hashed_process_data->draw_context->current->middle->x = -1;
  hashed_process_data->draw_context->current->middle->y = -1;
  hashed_process_data->draw_context->current->under = g_new(ItemInfo,1);
  hashed_process_data->draw_context->current->under->x = -1;
  hashed_process_data->draw_context->current->under->y = -1;
  hashed_process_data->draw_context->current->modify_over = g_new(ItemInfo,1);
  hashed_process_data->draw_context->current->modify_over->x = -1;
  hashed_process_data->draw_context->current->modify_over->y = -1;
  hashed_process_data->draw_context->current->modify_middle = g_new(ItemInfo,1);
  hashed_process_data->draw_context->current->modify_middle->x = -1;
  hashed_process_data->draw_context->current->modify_middle->y = -1;
  hashed_process_data->draw_context->current->modify_under = g_new(ItemInfo,1);
  hashed_process_data->draw_context->current->modify_under->x = -1;
  hashed_process_data->draw_context->current->modify_under->y = -1;
  hashed_process_data->draw_context->current->status = LTTV_STATE_UNNAMED;
  hashed_process_data->draw_context->previous = g_new(DrawInfo,1);
  hashed_process_data->draw_context->previous->over = g_new(ItemInfo,1);
  hashed_process_data->draw_context->previous->over->x = -1;
  hashed_process_data->draw_context->previous->over->y = -1;
  hashed_process_data->draw_context->previous->middle = g_new(ItemInfo,1);
  hashed_process_data->draw_context->previous->middle->x = -1;
  hashed_process_data->draw_context->previous->middle->y = -1;
  hashed_process_data->draw_context->previous->under = g_new(ItemInfo,1);
  hashed_process_data->draw_context->previous->under->x = -1;
  hashed_process_data->draw_context->previous->under->y = -1;
  hashed_process_data->draw_context->previous->modify_over = g_new(ItemInfo,1);
  hashed_process_data->draw_context->previous->modify_over->x = -1;
  hashed_process_data->draw_context->previous->modify_over->y = -1;
  hashed_process_data->draw_context->previous->modify_middle = g_new(ItemInfo,1);
  hashed_process_data->draw_context->previous->modify_middle->x = -1;
  hashed_process_data->draw_context->previous->modify_middle->y = -1;
  hashed_process_data->draw_context->previous->modify_under = g_new(ItemInfo,1);
  hashed_process_data->draw_context->previous->modify_under->x = -1;
  hashed_process_data->draw_context->previous->modify_under->y = -1;
  hashed_process_data->draw_context->previous->status = LTTV_STATE_UNNAMED;
  
  /* Add a new row to the model */
  gtk_list_store_append ( process_list->list_store, &iter);
  //g_critical ( "iter before : %s", gtk_tree_path_to_string (
  //    gtk_tree_model_get_path (
  //        GTK_TREE_MODEL(process_list->list_store),
  //        &iter)));
  gtk_list_store_set (  process_list->list_store, &iter,
        PROCESS_COLUMN, name,
        PID_COLUMN, pid,
        BIRTH_S_COLUMN, birth->tv_sec,
        BIRTH_NS_COLUMN, birth->tv_nsec,
        TRACE_COLUMN, trace_num,
        -1);
  hashed_process_data->row_ref = gtk_tree_row_reference_new (
      GTK_TREE_MODEL(process_list->list_store),
      gtk_tree_model_get_path(
        GTK_TREE_MODEL(process_list->list_store),
        &iter));
  g_hash_table_insert(  process_list->process_hash,
        (gpointer)Process_Info,
        (gpointer)hashed_process_data);
  
  //g_critical ( "iter after : %s", gtk_tree_path_to_string (
  //    gtk_tree_model_get_path (
  //        GTK_TREE_MODEL(process_list->list_store),
  //        &iter)));
  process_list->number_of_process++;

  *height = get_cell_height(GTK_TREE_VIEW(process_list->process_list_widget))
        * process_list->number_of_process ;
  
  
  return 0;
  
}

int processlist_remove( ProcessList *process_list,
      guint pid,
      LttTime *birth,
      guint trace_num)
{
  ProcessInfo Process_Info;
  gint *path_indices;
  HashedProcessData *hashed_process_data;
  GtkTreeIter iter;
  
  Process_Info.pid = pid;
  Process_Info.birth = *birth;
  Process_Info.trace_num = trace_num;


  if(hashed_process_data = 
    (HashedProcessData*)g_hash_table_lookup(
          process_list->process_hash,
          &Process_Info))
  {
    GtkTreePath *tree_path;

    tree_path = gtk_tree_row_reference_get_path(
                    hashed_process_data->row_ref);

    gtk_tree_model_get_iter (
        GTK_TREE_MODEL(process_list->list_store),
        &iter, tree_path);
 
    gtk_tree_path_free(tree_path);

    gtk_list_store_remove (process_list->list_store, &iter);
    
    g_free(hashed_process_data->draw_context->previous->modify_under);
    g_free(hashed_process_data->draw_context->previous->modify_middle);
    g_free(hashed_process_data->draw_context->previous->modify_over);
    g_free(hashed_process_data->draw_context->previous->under);
    g_free(hashed_process_data->draw_context->previous->middle);
    g_free(hashed_process_data->draw_context->previous->over);
    g_free(hashed_process_data->draw_context->previous);
    g_free(hashed_process_data->draw_context->current->modify_under);
    g_free(hashed_process_data->draw_context->current->modify_middle);
    g_free(hashed_process_data->draw_context->current->modify_over);
    g_free(hashed_process_data->draw_context->current->under);
    g_free(hashed_process_data->draw_context->current->middle);
    g_free(hashed_process_data->draw_context->current->over);
    g_free(hashed_process_data->draw_context->current);
    g_free(hashed_process_data->draw_context);
    g_free(hashed_process_data);

    g_hash_table_remove(process_list->process_hash,
        &Process_Info);
    
    process_list->number_of_process--;

    return 0; 
  } else {
    return 1;
  }
}


guint processlist_get_height(ProcessList *process_list)
{
  return get_cell_height(GTK_TREE_VIEW(process_list->process_list_widget))
        * process_list->number_of_process ;
}


gint processlist_get_process_pixels(  ProcessList *process_list,
          guint pid, LttTime *birth, guint trace_num,
          guint *y,
          guint *height,
          HashedProcessData **pm_hashed_process_data)
{
  ProcessInfo Process_Info;
  gint *path_indices;
  GtkTreePath *tree_path;
  HashedProcessData *hashed_process_data = NULL;

  Process_Info.pid = pid;
  Process_Info.birth = *birth;
  Process_Info.trace_num = trace_num;

  if(hashed_process_data = 
    (HashedProcessData*)g_hash_table_lookup(
          process_list->process_hash,
          &Process_Info))
  {
    tree_path = gtk_tree_row_reference_get_path(
                    hashed_process_data->row_ref);
    path_indices =  gtk_tree_path_get_indices (tree_path);

    *height = get_cell_height(
        GTK_TREE_VIEW(process_list->process_list_widget));
    *y = *height * path_indices[0];
    *pm_hashed_process_data = hashed_process_data;
    gtk_tree_path_free(tree_path);
    
    return 0; 
  } else {
    *pm_hashed_process_data = hashed_process_data;
    return 1;
  }

}


gint processlist_get_pixels_from_data(  ProcessList *process_list,
          ProcessInfo *process_info,
          HashedProcessData *hashed_process_data,
          guint *y,
          guint *height)
{
  gint *path_indices;
  GtkTreePath *tree_path;

  tree_path = gtk_tree_row_reference_get_path(
                  hashed_process_data->row_ref);
  path_indices =  gtk_tree_path_get_indices (tree_path);

  *height = get_cell_height(
      GTK_TREE_VIEW(process_list->process_list_widget));
  *y = *height * path_indices[0];
  gtk_tree_path_free(tree_path);

  return 0; 

}
Commit	Line	Data
ce0214a6	1	/* This file is part of the Linux Trace Toolkit viewer
	2	* Copyright (C) 2003-2004 Mathieu Desnoyers
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License Version 2 as
	6	* published by the Free Software Foundation;
	7	*
	8	* This program is distributed in the hope that it will be useful,
	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	* GNU General Public License for more details.
	12	*
	13	* You should have received a copy of the GNU General Public License
	14	* along with this program; if not, write to the Free Software
	15	* Foundation, Inc., 59 Temple Place - Suite 330, Boston,
	16	* MA 02111-1307, USA.
	17	*/
f0d936c0	18
fa2c4dbe	19	#include <gtk/gtk.h>
fa2c4dbe	20	#include <glib.h>
d66666fe	21
	22	#include "processlist.h"
	23	#include "drawitem.h"
fa2c4dbe	24
ca0f8a8e	25	#define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format)
	26	#define g_debug(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format)
	27
	28
f0d936c0	29	/*****************************************************************************
	30	* Methods to synchronize process list *
	31	*****************************************************************************/
	32
f0d936c0	33	/* Enumeration of the columns */
	34	enum
	35	{
a56a1ba4	36	PROCESS_COLUMN,
	37	PID_COLUMN,
	38	BIRTH_S_COLUMN,
	39	BIRTH_NS_COLUMN,
d0cd7f09	40	TRACE_COLUMN,
a56a1ba4	41	N_COLUMNS
f0d936c0	42	};
	43
	44
a56a1ba4	45	gint process_sort_func ( GtkTreeModel *model,
	46	GtkTreeIter *it_a,
	47	GtkTreeIter *it_b,
	48	gpointer user_data)
fa2c4dbe	49	{
a56a1ba4	50	GValue a, b;
	51
	52	memset(&a, 0, sizeof(GValue));
	53	memset(&b, 0, sizeof(GValue));
	54
	55	/* Order by PID */
	56	gtk_tree_model_get_value( model,
	57	it_a,
	58	PID_COLUMN,
	59	&a);
	60
	61	gtk_tree_model_get_value( model,
	62	it_b,
	63	PID_COLUMN,
	64	&b);
	65
	66	if(G_VALUE_TYPE(&a) == G_TYPE_UINT
	67	&& G_VALUE_TYPE(&b) == G_TYPE_UINT )
	68	{
	69	if(g_value_get_uint(&a) > g_value_get_uint(&b))
	70	{
	71	g_value_unset(&a);
	72	g_value_unset(&b);
	73	return 1;
	74	}
	75	if(g_value_get_uint(&a) < g_value_get_uint(&b))
	76	{
	77	g_value_unset(&a);
	78	g_value_unset(&b);
	79	return 0;
	80	}
	81	}
	82
	83	g_value_unset(&a);
	84	g_value_unset(&b);
	85
	86
	87	/* Order by birth second */
	88	gtk_tree_model_get_value( model,
	89	it_a,
	90	BIRTH_S_COLUMN,
	91	&a);
	92
	93	gtk_tree_model_get_value( model,
	94	it_b,
	95	BIRTH_S_COLUMN,
	96	&b);
	97
	98
	99	if(G_VALUE_TYPE(&a) == G_TYPE_ULONG
	100	&& G_VALUE_TYPE(&b) == G_TYPE_ULONG )
	101	{
	102	if(g_value_get_ulong(&a) > g_value_get_ulong(&b))
	103	{
	104	g_value_unset(&a);
	105	g_value_unset(&b);
	106	return 1;
	107	}
	108	if(g_value_get_ulong(&a) < g_value_get_ulong(&b))
	109	{
	110	g_value_unset(&a);
	111	g_value_unset(&b);
	112	return 0;
	113	}
114
115	}
116
117	g_value_unset(&a);
118	g_value_unset(&b);
119
120	/* Order by birth nanosecond */
121	gtk_tree_model_get_value( model,
122	it_a,
123	BIRTH_NS_COLUMN,
124	&a);
125
126	gtk_tree_model_get_value( model,
127	it_b,
128	BIRTH_NS_COLUMN,
129	&b);
130
131
132	if(G_VALUE_TYPE(&a) == G_TYPE_ULONG
133	&& G_VALUE_TYPE(&b) == G_TYPE_ULONG )
134	{
135	if(g_value_get_ulong(&a) > g_value_get_ulong(&b))
136	{
137	g_value_unset(&a);
138	g_value_unset(&b);
139	return 1;
140	}
141	// Final condition
142	//if(g_value_get_ulong(&a) < g_value_get_ulong(&b))
143	//{
144	// g_value_unset(&a);
145	// g_value_unset(&b);
146	// return 0;
147	//}
148
149	}
150
151	g_value_unset(&a);
152	g_value_unset(&b);
153
d0cd7f09	154	/* Order by trace_num */
	155	gtk_tree_model_get_value( model,
	156	it_a,
	157	TRACE_COLUMN,
	158	&a);
	159
	160	gtk_tree_model_get_value( model,
	161	it_b,
	162	TRACE_COLUMN,
	163	&b);
	164
	165	if(G_VALUE_TYPE(&a) == G_TYPE_ULONG
	166	&& G_VALUE_TYPE(&b) == G_TYPE_ULONG )
	167	{
	168	if(g_value_get_ulong(&a) > g_value_get_ulong(&b))
	169	{
	170	g_value_unset(&a);
	171	g_value_unset(&b);
	172	return 1;
	173	}
	174	if(g_value_get_ulong(&a) < g_value_get_ulong(&b))
	175	{
	176	g_value_unset(&a);
	177	g_value_unset(&b);
	178	return 0;
	179	}
	180
	181	}
	182
	183
	184
a56a1ba4	185	return 0;
fa2c4dbe	186
	187	}
	188
fa2c4dbe	189	guint hash_fct(gconstpointer key)
fa2c4dbe	190	{
a56a1ba4	191	return ((ProcessInfo*)key)->pid;
fa2c4dbe	192	}
	193
	194	gboolean equ_fct(gconstpointer a, gconstpointer b)
	195	{
a56a1ba4	196	if(((ProcessInfo)a)->pid != ((ProcessInfo)b)->pid)
	197	return 0;
	198	// g_critical("compare %u and %u",((ProcessInfo)a)->pid,((ProcessInfo)b)->pid);
	199	if(((ProcessInfo)a)->birth.tv_sec != ((ProcessInfo)b)->birth.tv_sec)
	200	return 0;
	201	// g_critical("compare %u and %u",((ProcessInfo)a)->birth.tv_sec,((ProcessInfo)b)->birth.tv_sec);
	202
	203	if(((ProcessInfo)a)->birth.tv_nsec != ((ProcessInfo)b)->birth.tv_nsec)
	204	return 0;
	205	// g_critical("compare %u and %u",((ProcessInfo)a)->birth.tv_nsec,((ProcessInfo)b)->birth.tv_nsec);
	206
d0cd7f09	207	if(((ProcessInfo)a)->trace_num != ((ProcessInfo)b)->trace_num)
	208	return 0;
	209
a56a1ba4	210	return 1;
fa2c4dbe	211	}
fa2c4dbe	212
4c69e0cc	213	void destroy_hash_key(gpointer key);
fa2c4dbe	214
4c69e0cc	215	void destroy_hash_data(gpointer data);
fa2c4dbe	216
	217
	218
	219
4c69e0cc	220	ProcessList *processlist_construct(void)
f0d936c0	221	{
a56a1ba4	222	GtkTreeViewColumn *column;
	223	GtkCellRenderer *renderer;
	224
ba90bc77	225	ProcessList* process_list = g_new(ProcessList,1);
a56a1ba4	226
ba90bc77	227	process_list->number_of_process = 0;
a56a1ba4	228
a56a1ba4	229	/* Create the Process list */
f5d980bf	230	process_list->list_store = gtk_list_store_new ( N_COLUMNS,
a56a1ba4	231	G_TYPE_STRING,
	232	G_TYPE_UINT,
	233	G_TYPE_ULONG,
d0cd7f09	234	G_TYPE_ULONG,
a56a1ba4	235	G_TYPE_ULONG);
	236
	237
f5d980bf	238	process_list->process_list_widget =
a56a1ba4	239	gtk_tree_view_new_with_model
f5d980bf	240	(GTK_TREE_MODEL (process_list->list_store));
f5d980bf	241	g_object_unref (G_OBJECT (process_list->list_store));
a56a1ba4	242
a56a1ba4	243	gtk_tree_sortable_set_sort_func(
f5d980bf	244	GTK_TREE_SORTABLE(process_list->list_store),
a56a1ba4	245	PID_COLUMN,
	246	process_sort_func,
	247	NULL,
	248	NULL);
	249
	250	gtk_tree_sortable_set_sort_column_id(
f5d980bf	251	GTK_TREE_SORTABLE(process_list->list_store),
a56a1ba4	252	PID_COLUMN,
	253	GTK_SORT_ASCENDING);
	254
14963be0	255	process_list->process_hash = g_hash_table_new_full(
a56a1ba4	256	hash_fct, equ_fct,
	257	destroy_hash_key, destroy_hash_data
	258	);
	259
	260
	261	gtk_tree_view_set_headers_visible(
3cb8b205	262	GTK_TREE_VIEW(process_list->process_list_widget), TRUE);
a56a1ba4	263
	264	/* Create a column, associating the "text" attribute of the
	265	* cell_renderer to the first column of the model */
	266	/* Columns alignment : 0.0 : Left 0.5 : Center 1.0 : Right */
	267	renderer = gtk_cell_renderer_text_new ();
	268	column = gtk_tree_view_column_new_with_attributes ( "Process",
	269	renderer,
	270	"text",
	271	PROCESS_COLUMN,
	272	NULL);
	273	gtk_tree_view_column_set_alignment (column, 0.0);
	274	gtk_tree_view_column_set_fixed_width (column, 45);
	275	gtk_tree_view_append_column (
f5d980bf	276	GTK_TREE_VIEW (process_list->process_list_widget), column);
a56a1ba4	277
	278	column = gtk_tree_view_column_new_with_attributes ( "PID",
	279	renderer,
	280	"text",
	281	PID_COLUMN,
	282	NULL);
	283	gtk_tree_view_append_column (
f5d980bf	284	GTK_TREE_VIEW (process_list->process_list_widget), column);
a56a1ba4	285
	286
	287	column = gtk_tree_view_column_new_with_attributes ( "Birth sec",
	288	renderer,
	289	"text",
	290	BIRTH_S_COLUMN,
	291	NULL);
	292	gtk_tree_view_append_column (
f5d980bf	293	GTK_TREE_VIEW (process_list->process_list_widget), column);
a56a1ba4	294
	295	//gtk_tree_view_column_set_visible(column, 0);
	296	//
	297	column = gtk_tree_view_column_new_with_attributes ( "Birth nsec",
	298	renderer,
	299	"text",
	300	BIRTH_NS_COLUMN,
	301	NULL);
	302	gtk_tree_view_append_column (
f5d980bf	303	GTK_TREE_VIEW (process_list->process_list_widget), column);
a56a1ba4	304
d0cd7f09	305	column = gtk_tree_view_column_new_with_attributes ( "TRACE",
	306	renderer,
	307	"text",
	308	TRACE_COLUMN,
	309	NULL);
	310	gtk_tree_view_append_column (
	311	GTK_TREE_VIEW (process_list->process_list_widget), column);
	312
	313
a56a1ba4	314	//gtk_tree_view_column_set_visible(column, 0);
	315
	316	g_object_set_data_full(
f5d980bf	317	G_OBJECT(process_list->process_list_widget),
ba90bc77	318	"process_list_Data",
ba90bc77	319	process_list,
a56a1ba4	320	(GDestroyNotify)processlist_destroy);
a56a1ba4	321
ba90bc77	322	return process_list;
f0d936c0	323	}
ba90bc77	324	void processlist_destroy(ProcessList *process_list)
f0d936c0	325	{
ca0f8a8e	326	g_info("processlist_destroy %p", process_list);
14963be0	327	g_hash_table_destroy(process_list->process_hash);
14963be0	328	process_list->process_hash = NULL;
f0d936c0	329
ba90bc77	330	g_free(process_list);
ca0f8a8e	331	g_info("processlist_destroy end");
f0d936c0	332	}
f0d936c0	333
ba90bc77	334	GtkWidget processlist_get_widget(ProcessList process_list)
f0d936c0	335	{
f5d980bf	336	return process_list->process_list_widget;
f0d936c0	337	}
	338
	339
	340
f5d980bf	341	gint get_cell_height(GtkTreeView *tree_view)
f0d936c0	342	{
a56a1ba4	343	gint height;
f5d980bf	344	GtkTreeViewColumn *Column = gtk_tree_view_get_column(tree_view, 0);
a56a1ba4	345	//GList *Render_List = gtk_tree_view_column_get_cell_renderers(Column);
	346	//GtkCellRenderer *Renderer = g_list_first(Render_List)->data;
	347
	348	//g_list_free(Render_List);
	349	gtk_tree_view_column_cell_get_size(Column, NULL, NULL, NULL, NULL, &height);
	350	//g_critical("cell 0 height : %u",height);
	351
	352	return height;
f0d936c0	353	}
f0d936c0	354
4c69e0cc	355	void destroy_hash_key(gpointer key)
f0d936c0	356	{
a56a1ba4	357	g_free(key);
fa2c4dbe	358	}
fa2c4dbe	359
4c69e0cc	360	void destroy_hash_data(gpointer data)
fa2c4dbe	361	{
a56a1ba4	362	g_free(data);
fa2c4dbe	363	}
fa2c4dbe	364
ba90bc77	365	int processlist_add( ProcessList *process_list,
a56a1ba4	366	guint pid,
a56a1ba4	367	LttTime *birth,
d0cd7f09	368	guint trace_num,
51705146	369	const gchar *name,
a56a1ba4	370	guint *height,
f5d980bf	371	HashedProcessData **pm_hashed_process_data)
fa2c4dbe	372	{
a56a1ba4	373	GtkTreeIter iter ;
a56a1ba4	374	ProcessInfo *Process_Info = g_new(ProcessInfo, 1);
14963be0	375	HashedProcessData *hashed_process_data = g_new(HashedProcessData, 1);
f5d980bf	376	*pm_hashed_process_data = hashed_process_data;
a56a1ba4	377
	378	Process_Info->pid = pid;
	379	Process_Info->birth = *birth;
d0cd7f09	380	Process_Info->trace_num = trace_num;
a56a1ba4	381
14963be0	382	hashed_process_data->draw_context = g_new(DrawContext, 1);
	383	hashed_process_data->draw_context->drawable = NULL;
	384	hashed_process_data->draw_context->gc = NULL;
	385	hashed_process_data->draw_context->pango_layout = NULL;
	386	hashed_process_data->draw_context->current = g_new(DrawInfo,1);
	387	hashed_process_data->draw_context->current->over = g_new(ItemInfo,1);
	388	hashed_process_data->draw_context->current->over->x = -1;
	389	hashed_process_data->draw_context->current->over->y = -1;
	390	hashed_process_data->draw_context->current->middle = g_new(ItemInfo,1);
	391	hashed_process_data->draw_context->current->middle->x = -1;
	392	hashed_process_data->draw_context->current->middle->y = -1;
	393	hashed_process_data->draw_context->current->under = g_new(ItemInfo,1);
	394	hashed_process_data->draw_context->current->under->x = -1;
	395	hashed_process_data->draw_context->current->under->y = -1;
	396	hashed_process_data->draw_context->current->modify_over = g_new(ItemInfo,1);
	397	hashed_process_data->draw_context->current->modify_over->x = -1;
	398	hashed_process_data->draw_context->current->modify_over->y = -1;
	399	hashed_process_data->draw_context->current->modify_middle = g_new(ItemInfo,1);
	400	hashed_process_data->draw_context->current->modify_middle->x = -1;
	401	hashed_process_data->draw_context->current->modify_middle->y = -1;
	402	hashed_process_data->draw_context->current->modify_under = g_new(ItemInfo,1);
	403	hashed_process_data->draw_context->current->modify_under->x = -1;
	404	hashed_process_data->draw_context->current->modify_under->y = -1;
	405	hashed_process_data->draw_context->current->status = LTTV_STATE_UNNAMED;
	406	hashed_process_data->draw_context->previous = g_new(DrawInfo,1);
	407	hashed_process_data->draw_context->previous->over = g_new(ItemInfo,1);
	408	hashed_process_data->draw_context->previous->over->x = -1;
	409	hashed_process_data->draw_context->previous->over->y = -1;
	410	hashed_process_data->draw_context->previous->middle = g_new(ItemInfo,1);
	411	hashed_process_data->draw_context->previous->middle->x = -1;
	412	hashed_process_data->draw_context->previous->middle->y = -1;
	413	hashed_process_data->draw_context->previous->under = g_new(ItemInfo,1);
	414	hashed_process_data->draw_context->previous->under->x = -1;
	415	hashed_process_data->draw_context->previous->under->y = -1;
	416	hashed_process_data->draw_context->previous->modify_over = g_new(ItemInfo,1);
	417	hashed_process_data->draw_context->previous->modify_over->x = -1;
	418	hashed_process_data->draw_context->previous->modify_over->y = -1;
	419	hashed_process_data->draw_context->previous->modify_middle = g_new(ItemInfo,1);
	420	hashed_process_data->draw_context->previous->modify_middle->x = -1;
	421	hashed_process_data->draw_context->previous->modify_middle->y = -1;
	422	hashed_process_data->draw_context->previous->modify_under = g_new(ItemInfo,1);
	423	hashed_process_data->draw_context->previous->modify_under->x = -1;
	424	hashed_process_data->draw_context->previous->modify_under->y = -1;
	425	hashed_process_data->draw_context->previous->status = LTTV_STATE_UNNAMED;
a56a1ba4	426
a56a1ba4	427	/* Add a new row to the model */
f5d980bf	428	gtk_list_store_append ( process_list->list_store, &iter);
a56a1ba4	429	//g_critical ( "iter before : %s", gtk_tree_path_to_string (
a56a1ba4	430	// gtk_tree_model_get_path (
f5d980bf	431	// GTK_TREE_MODEL(process_list->list_store),
a56a1ba4	432	// &iter)));
f5d980bf	433	gtk_list_store_set ( process_list->list_store, &iter,
a56a1ba4	434	PROCESS_COLUMN, name,
	435	PID_COLUMN, pid,
	436	BIRTH_S_COLUMN, birth->tv_sec,
	437	BIRTH_NS_COLUMN, birth->tv_nsec,
d0cd7f09	438	TRACE_COLUMN, trace_num,
a56a1ba4	439	-1);
f5d980bf	440	hashed_process_data->row_ref = gtk_tree_row_reference_new (
f5d980bf	441	GTK_TREE_MODEL(process_list->list_store),
a56a1ba4	442	gtk_tree_model_get_path(
f5d980bf	443	GTK_TREE_MODEL(process_list->list_store),
a56a1ba4	444	&iter));
14963be0	445	g_hash_table_insert( process_list->process_hash,
a56a1ba4	446	(gpointer)Process_Info,
14963be0	447	(gpointer)hashed_process_data);
a56a1ba4	448
	449	//g_critical ( "iter after : %s", gtk_tree_path_to_string (
	450	// gtk_tree_model_get_path (
f5d980bf	451	// GTK_TREE_MODEL(process_list->list_store),
a56a1ba4	452	// &iter)));
ba90bc77	453	process_list->number_of_process++;
a56a1ba4	454
f5d980bf	455	*height = get_cell_height(GTK_TREE_VIEW(process_list->process_list_widget))
ba90bc77	456	* process_list->number_of_process ;
a56a1ba4	457
	458
	459	return 0;
	460
f0d936c0	461	}
f0d936c0	462
ba90bc77	463	int processlist_remove( ProcessList *process_list,
a56a1ba4	464	guint pid,
d0cd7f09	465	LttTime *birth,
d0cd7f09	466	guint trace_num)
f0d936c0	467	{
a56a1ba4	468	ProcessInfo Process_Info;
a56a1ba4	469	gint *path_indices;
14963be0	470	HashedProcessData *hashed_process_data;
a56a1ba4	471	GtkTreeIter iter;
	472
	473	Process_Info.pid = pid;
	474	Process_Info.birth = *birth;
d0cd7f09	475	Process_Info.trace_num = trace_num;
a56a1ba4	476
a56a1ba4	477
14963be0	478	if(hashed_process_data =
a56a1ba4	479	(HashedProcessData*)g_hash_table_lookup(
14963be0	480	process_list->process_hash,
a56a1ba4	481	&Process_Info))
a56a1ba4	482	{
51705146	483	GtkTreePath *tree_path;
	484
	485	tree_path = gtk_tree_row_reference_get_path(
	486	hashed_process_data->row_ref);
	487
a56a1ba4	488	gtk_tree_model_get_iter (
f5d980bf	489	GTK_TREE_MODEL(process_list->list_store),
51705146	490	&iter, tree_path);
	491
	492	gtk_tree_path_free(tree_path);
a56a1ba4	493
f5d980bf	494	gtk_list_store_remove (process_list->list_store, &iter);
a56a1ba4	495
14963be0	496	g_free(hashed_process_data->draw_context->previous->modify_under);
	497	g_free(hashed_process_data->draw_context->previous->modify_middle);
	498	g_free(hashed_process_data->draw_context->previous->modify_over);
	499	g_free(hashed_process_data->draw_context->previous->under);
	500	g_free(hashed_process_data->draw_context->previous->middle);
	501	g_free(hashed_process_data->draw_context->previous->over);
	502	g_free(hashed_process_data->draw_context->previous);
	503	g_free(hashed_process_data->draw_context->current->modify_under);
	504	g_free(hashed_process_data->draw_context->current->modify_middle);
	505	g_free(hashed_process_data->draw_context->current->modify_over);
	506	g_free(hashed_process_data->draw_context->current->under);
	507	g_free(hashed_process_data->draw_context->current->middle);
	508	g_free(hashed_process_data->draw_context->current->over);
	509	g_free(hashed_process_data->draw_context->current);
	510	g_free(hashed_process_data->draw_context);
	511	g_free(hashed_process_data);
	512
	513	g_hash_table_remove(process_list->process_hash,
a56a1ba4	514	&Process_Info);
a56a1ba4	515
ba90bc77	516	process_list->number_of_process--;
a56a1ba4	517
	518	return 0;
	519	} else {
	520	return 1;
	521	}
fa2c4dbe	522	}
	523
	524
ba90bc77	525	guint processlist_get_height(ProcessList *process_list)
fa2c4dbe	526	{
f5d980bf	527	return get_cell_height(GTK_TREE_VIEW(process_list->process_list_widget))
ba90bc77	528	* process_list->number_of_process ;
f0d936c0	529	}
fa2c4dbe	530
fa2c4dbe	531
ba90bc77	532	gint processlist_get_process_pixels( ProcessList *process_list,
d0cd7f09	533	guint pid, LttTime *birth, guint trace_num,
a56a1ba4	534	guint *y,
a56a1ba4	535	guint *height,
f5d980bf	536	HashedProcessData **pm_hashed_process_data)
fa2c4dbe	537	{
a56a1ba4	538	ProcessInfo Process_Info;
	539	gint *path_indices;
	540	GtkTreePath *tree_path;
14963be0	541	HashedProcessData *hashed_process_data = NULL;
a56a1ba4	542
	543	Process_Info.pid = pid;
	544	Process_Info.birth = *birth;
d0cd7f09	545	Process_Info.trace_num = trace_num;
a56a1ba4	546
14963be0	547	if(hashed_process_data =
a56a1ba4	548	(HashedProcessData*)g_hash_table_lookup(
14963be0	549	process_list->process_hash,
a56a1ba4	550	&Process_Info))
	551	{
	552	tree_path = gtk_tree_row_reference_get_path(
f5d980bf	553	hashed_process_data->row_ref);
a56a1ba4	554	path_indices = gtk_tree_path_get_indices (tree_path);
	555
	556	*height = get_cell_height(
f5d980bf	557	GTK_TREE_VIEW(process_list->process_list_widget));
a56a1ba4	558	y = height * path_indices[0];
f5d980bf	559	*pm_hashed_process_data = hashed_process_data;
51705146	560	gtk_tree_path_free(tree_path);
51705146	561
a56a1ba4	562	return 0;
a56a1ba4	563	} else {
f5d980bf	564	*pm_hashed_process_data = hashed_process_data;
a56a1ba4	565	return 1;
a56a1ba4	566	}
fa2c4dbe	567
fa2c4dbe	568	}
8b90e648	569
8b90e648	570
ba90bc77	571	gint processlist_get_pixels_from_data( ProcessList *process_list,
a56a1ba4	572	ProcessInfo *process_info,
14963be0	573	HashedProcessData *hashed_process_data,
a56a1ba4	574	guint *y,
a56a1ba4	575	guint *height)
8b90e648	576	{
a56a1ba4	577	gint *path_indices;
a56a1ba4	578	GtkTreePath *tree_path;
8b90e648	579
a56a1ba4	580	tree_path = gtk_tree_row_reference_get_path(
f5d980bf	581	hashed_process_data->row_ref);
a56a1ba4	582	path_indices = gtk_tree_path_get_indices (tree_path);
8b90e648	583
a56a1ba4	584	*height = get_cell_height(
f5d980bf	585	GTK_TREE_VIEW(process_list->process_list_widget));
a56a1ba4	586	y = height * path_indices[0];
51705146	587	gtk_tree_path_free(tree_path);
8b90e648	588
a56a1ba4	589	return 0;
8b90e648	590
8b90e648	591	}