[lttv.git] / ltt / branches / poly / lttv / modules / guiControlFlow / Process_List.c


#include <gtk/gtk.h>
#include <glib.h>
#include "Process_List.h"
#include "Draw_Item.h"

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

/* Enumeration of the columns */
enum
{
	PROCESS_COLUMN,
	PID_COLUMN,
	BIRTH_S_COLUMN,
	BIRTH_NS_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);

	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);

	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->Store_M = gtk_list_store_new ( 	N_COLUMNS,
							G_TYPE_STRING,
							G_TYPE_UINT,
							G_TYPE_ULONG,
							G_TYPE_ULONG);


	Process_List->Process_List_VC = 
		gtk_tree_view_new_with_model
		(GTK_TREE_MODEL (Process_List->Store_M));

	g_object_unref (G_OBJECT (Process_List->Store_M));

	gtk_tree_sortable_set_sort_func(
			GTK_TREE_SORTABLE(Process_List->Store_M),
			PID_COLUMN,
			process_sort_func,
			NULL,
			NULL);
	
	gtk_tree_sortable_set_sort_column_id(
			GTK_TREE_SORTABLE(Process_List->Store_M),
			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_VC), FALSE);

	/* 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_VC), 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_VC), 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_VC), 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_VC), column);

	//gtk_tree_view_column_set_visible(column, 0);
	
	g_object_set_data_full(
			G_OBJECT(Process_List->Process_List_VC),
			"Process_List_Data",
			Process_List,
			(GDestroyNotify)processlist_destroy);

	Process_List->Test_Process_Sent = 0;
	
	return Process_List;
}
void processlist_destroy(ProcessList *Process_List)
{
	g_hash_table_destroy(Process_List->Process_Hash);
	Process_List->Process_Hash = NULL;

	g_free(Process_List);
}

GtkWidget *processlist_get_widget(ProcessList *Process_List)
{
	return Process_List->Process_List_VC;
}


gint get_cell_height(GtkTreeView *TreeView)
{
	gint height;
	GtkTreeViewColumn *Column = gtk_tree_view_get_column(TreeView, 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,
			gchar *name,
			guint *height,
			HashedProcessData **pmHashed_Process_Data)
{
	GtkTreeIter iter ;
	ProcessInfo *Process_Info = g_new(ProcessInfo, 1);
	HashedProcessData *Hashed_Process_Data = g_new(HashedProcessData, 1);
	*pmHashed_Process_Data = Hashed_Process_Data;
	
	Process_Info->pid = pid;
	Process_Info->birth = *birth;
	
	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->Store_M, &iter);
	//g_critical ( "iter before : %s", gtk_tree_path_to_string (
	//		gtk_tree_model_get_path (
	//				GTK_TREE_MODEL(Process_List->Store_M),
	//				&iter)));
	gtk_list_store_set (	Process_List->Store_M, &iter,
				PROCESS_COLUMN, name,
				PID_COLUMN, pid,
				BIRTH_S_COLUMN, birth->tv_sec,
				BIRTH_NS_COLUMN, birth->tv_nsec,
				-1);
	Hashed_Process_Data->RowRef = gtk_tree_row_reference_new (
			GTK_TREE_MODEL(Process_List->Store_M),
			gtk_tree_model_get_path(
				GTK_TREE_MODEL(Process_List->Store_M),
				&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->Store_M),
	//				&iter)));
	Process_List->Number_Of_Process++;

	*height = get_cell_height(GTK_TREE_VIEW(Process_List->Process_List_VC))
				* Process_List->Number_Of_Process ;
	
	
	return 0;
	
}

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


	if(Hashed_Process_Data = 
		(HashedProcessData*)g_hash_table_lookup(
					Process_List->Process_Hash,
					&Process_Info))
	{
		gtk_tree_model_get_iter (
				GTK_TREE_MODEL(Process_List->Store_M),
				&iter,
				gtk_tree_row_reference_get_path(
					(GtkTreeRowReference*)Hashed_Process_Data->RowRef)
				);

		gtk_list_store_remove (Process_List->Store_M, &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_VC))
				* Process_List->Number_Of_Process ;
}


gint processlist_get_process_pixels(	ProcessList *Process_List,
					guint pid, LttTime *birth,
					guint *y,
					guint *height,
					HashedProcessData **pmHashed_Process_Data)
{
	ProcessInfo Process_Info;
	gint *path_indices;
	GtkTreePath *tree_path;
	HashedProcessData *Hashed_Process_Data = NULL;

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

	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->RowRef);
		path_indices =	gtk_tree_path_get_indices (tree_path);

	 	*height = get_cell_height(
				GTK_TREE_VIEW(Process_List->Process_List_VC));
		*y = *height * path_indices[0];
		*pmHashed_Process_Data = Hashed_Process_Data;
		return 0;	
	} else {
		*pmHashed_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->RowRef);
	path_indices =	gtk_tree_path_get_indices (tree_path);

	*height = get_cell_height(
			GTK_TREE_VIEW(Process_List->Process_List_VC));
	*y = *height * path_indices[0];

	return 0;	

}
Commit	Line	Data
f0d936c0	1
fa2c4dbe	2	#include <gtk/gtk.h>
fa2c4dbe	3	#include <glib.h>
f0d936c0	4	#include "Process_List.h"
80a52ff8	5	#include "Draw_Item.h"
fa2c4dbe	6
f0d936c0	7	/*****************************************************************************
	8	* Methods to synchronize process list *
	9	*****************************************************************************/
	10
f0d936c0	11	/* Enumeration of the columns */
	12	enum
	13	{
	14	PROCESS_COLUMN,
fa2c4dbe	15	PID_COLUMN,
	16	BIRTH_S_COLUMN,
	17	BIRTH_NS_COLUMN,
f0d936c0	18	N_COLUMNS
	19	};
	20
	21
fa2c4dbe	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
fa2c4dbe	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;
f7afe191	144	// g_critical("compare %u and %u",((ProcessInfo)a)->pid,((ProcessInfo)b)->pid);
fa2c4dbe	145	if(((ProcessInfo)a)->birth.tv_sec != ((ProcessInfo)b)->birth.tv_sec)
fa2c4dbe	146	return 0;
f7afe191	147	// g_critical("compare %u and %u",((ProcessInfo)a)->birth.tv_sec,((ProcessInfo)b)->birth.tv_sec);
fa2c4dbe	148
	149	if(((ProcessInfo)a)->birth.tv_nsec != ((ProcessInfo)b)->birth.tv_nsec)
	150	return 0;
f7afe191	151	// g_critical("compare %u and %u",((ProcessInfo)a)->birth.tv_nsec,((ProcessInfo)b)->birth.tv_nsec);
fa2c4dbe	152
	153	return 1;
	154	}
	155
4c69e0cc	156	void destroy_hash_key(gpointer key);
fa2c4dbe	157
4c69e0cc	158	void destroy_hash_data(gpointer data);
fa2c4dbe	159
	160
	161
	162
4c69e0cc	163	ProcessList *processlist_construct(void)
f0d936c0	164	{
	165	GtkTreeViewColumn *column;
	166	GtkCellRenderer *renderer;
	167
	168	ProcessList* Process_List = g_new(ProcessList,1);
	169
fa2c4dbe	170	Process_List->Number_Of_Process = 0;
fa2c4dbe	171
f0d936c0	172	/* Create the Process list */
f0d936c0	173	Process_List->Store_M = gtk_list_store_new ( N_COLUMNS,
fa2c4dbe	174	G_TYPE_STRING,
	175	G_TYPE_UINT,
	176	G_TYPE_ULONG,
	177	G_TYPE_ULONG);
f0d936c0	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
fa2c4dbe	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,
4c69e0cc	200	destroy_hash_key, destroy_hash_data
fa2c4dbe	201	);
	202
	203
f0d936c0	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);
fa2c4dbe	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);
f0d936c0	249
	250	g_object_set_data_full(
	251	G_OBJECT(Process_List->Process_List_VC),
	252	"Process_List_Data",
	253	Process_List,
4c69e0cc	254	(GDestroyNotify)processlist_destroy);
f7afe191	255
	256	Process_List->Test_Process_Sent = 0;
	257
f0d936c0	258	return Process_List;
f0d936c0	259	}
4c69e0cc	260	void processlist_destroy(ProcessList *Process_List)
f0d936c0	261	{
fa2c4dbe	262	g_hash_table_destroy(Process_List->Process_Hash);
fa2c4dbe	263	Process_List->Process_Hash = NULL;
f0d936c0	264
	265	g_free(Process_List);
	266	}
	267
4c69e0cc	268	GtkWidget processlist_get_widget(ProcessList Process_List)
f0d936c0	269	{
	270	return Process_List->Process_List_VC;
	271	}
	272
	273
	274
	275	gint get_cell_height(GtkTreeView *TreeView)
	276	{
fa2c4dbe	277	gint height;
f0d936c0	278	GtkTreeViewColumn *Column = gtk_tree_view_get_column(TreeView, 0);
8d088fb2	279	//GList *Render_List = gtk_tree_view_column_get_cell_renderers(Column);
8d088fb2	280	//GtkCellRenderer *Renderer = g_list_first(Render_List)->data;
f0d936c0	281
8d088fb2	282	//g_list_free(Render_List);
f0d936c0	283	gtk_tree_view_column_cell_get_size(Column, NULL, NULL, NULL, NULL, &height);
f7afe191	284	//g_critical("cell 0 height : %u",height);
f0d936c0	285
	286	return height;
	287	}
	288
4c69e0cc	289	void destroy_hash_key(gpointer key)
f0d936c0	290	{
fa2c4dbe	291	g_free(key);
	292	}
	293
4c69e0cc	294	void destroy_hash_data(gpointer data)
fa2c4dbe	295	{
	296	g_free(data);
	297	}
	298
4c69e0cc	299	int processlist_add( ProcessList *Process_List,
fa2c4dbe	300	guint pid,
fa2c4dbe	301	LttTime *birth,
432a7065	302	gchar *name,
80a52ff8	303	guint *height,
80a52ff8	304	HashedProcessData **pmHashed_Process_Data)
fa2c4dbe	305	{
	306	GtkTreeIter iter ;
	307	ProcessInfo *Process_Info = g_new(ProcessInfo, 1);
80a52ff8	308	HashedProcessData *Hashed_Process_Data = g_new(HashedProcessData, 1);
	309	*pmHashed_Process_Data = Hashed_Process_Data;
	310
fa2c4dbe	311	Process_Info->pid = pid;
	312	Process_Info->birth = *birth;
	313
80a52ff8	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;
34b04882	317	Hashed_Process_Data->draw_context->pango_layout = NULL;
80a52ff8	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;
8b90e648	337	Hashed_Process_Data->draw_context->Current->status = LTTV_STATE_UNNAMED;
80a52ff8	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;
8b90e648	357	Hashed_Process_Data->draw_context->Previous->status = LTTV_STATE_UNNAMED;
80a52ff8	358
fa2c4dbe	359	/* Add a new row to the model */
fa2c4dbe	360	gtk_list_store_append ( Process_List->Store_M, &iter);
f7afe191	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)));
fa2c4dbe	365	gtk_list_store_set ( Process_List->Store_M, &iter,
432a7065	366	PROCESS_COLUMN, name,
fa2c4dbe	367	PID_COLUMN, pid,
	368	BIRTH_S_COLUMN, birth->tv_sec,
	369	BIRTH_NS_COLUMN, birth->tv_nsec,
	370	-1);
80a52ff8	371	Hashed_Process_Data->RowRef = gtk_tree_row_reference_new (
fa2c4dbe	372	GTK_TREE_MODEL(Process_List->Store_M),
	373	gtk_tree_model_get_path(
	374	GTK_TREE_MODEL(Process_List->Store_M),
	375	&iter));
fa2c4dbe	376	g_hash_table_insert( Process_List->Process_Hash,
fa2c4dbe	377	(gpointer)Process_Info,
80a52ff8	378	(gpointer)Hashed_Process_Data);
fa2c4dbe	379
f7afe191	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)));
fa2c4dbe	384	Process_List->Number_Of_Process++;
f0d936c0	385
fa2c4dbe	386	*height = get_cell_height(GTK_TREE_VIEW(Process_List->Process_List_VC))
f0d936c0	387	* Process_List->Number_Of_Process ;
f0d936c0	388
fa2c4dbe	389
f0d936c0	390	return 0;
	391
	392	}
	393
4c69e0cc	394	int processlist_remove( ProcessList *Process_List,
fa2c4dbe	395	guint pid,
fa2c4dbe	396	LttTime *birth)
f0d936c0	397	{
fa2c4dbe	398	ProcessInfo Process_Info;
fa2c4dbe	399	gint *path_indices;
80a52ff8	400	HashedProcessData *Hashed_Process_Data;
fa2c4dbe	401	GtkTreeIter iter;
f0d936c0	402
fa2c4dbe	403	Process_Info.pid = pid;
	404	Process_Info.birth = *birth;
	405
80a52ff8	406
	407	if(Hashed_Process_Data =
	408	(HashedProcessData*)g_hash_table_lookup(
fa2c4dbe	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(
80a52ff8	416	(GtkTreeRowReference*)Hashed_Process_Data->RowRef)
fa2c4dbe	417	);
	418
	419	gtk_list_store_remove (Process_List->Store_M, &iter);
80a52ff8	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
fa2c4dbe	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
4c69e0cc	450	guint processlist_get_height(ProcessList *Process_List)
fa2c4dbe	451	{
fa2c4dbe	452	return get_cell_height(GTK_TREE_VIEW(Process_List->Process_List_VC))
f0d936c0	453	* Process_List->Number_Of_Process ;
f0d936c0	454	}
fa2c4dbe	455
fa2c4dbe	456
4c69e0cc	457	gint processlist_get_process_pixels( ProcessList *Process_List,
fa2c4dbe	458	guint pid, LttTime *birth,
f7afe191	459	guint *y,
80a52ff8	460	guint *height,
80a52ff8	461	HashedProcessData **pmHashed_Process_Data)
fa2c4dbe	462	{
	463	ProcessInfo Process_Info;
	464	gint *path_indices;
8d088fb2	465	GtkTreePath *tree_path;
80a52ff8	466	HashedProcessData *Hashed_Process_Data = NULL;
fa2c4dbe	467
	468	Process_Info.pid = pid;
	469	Process_Info.birth = *birth;
	470
80a52ff8	471	if(Hashed_Process_Data =
80a52ff8	472	(HashedProcessData*)g_hash_table_lookup(
fa2c4dbe	473	Process_List->Process_Hash,
	474	&Process_Info))
	475	{
8d088fb2	476	tree_path = gtk_tree_row_reference_get_path(
80a52ff8	477	Hashed_Process_Data->RowRef);
8d088fb2	478	path_indices = gtk_tree_path_get_indices (tree_path);
fa2c4dbe	479
	480	*height = get_cell_height(
	481	GTK_TREE_VIEW(Process_List->Process_List_VC));
f7afe191	482	y = height * path_indices[0];
80a52ff8	483	*pmHashed_Process_Data = Hashed_Process_Data;
fa2c4dbe	484	return 0;
fa2c4dbe	485	} else {
80a52ff8	486	*pmHashed_Process_Data = Hashed_Process_Data;
fa2c4dbe	487	return 1;
	488	}
	489
fa2c4dbe	490	}
8b90e648	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	}