with Gtk.Menu_Item; use Gtk.Menu_Item;
with Gtk;            use Gtk;
with Gtk.Main;       use Gtk.Main;
with Glib.Error;     use Glib.Error;
with Gtk.Widget;     use Gtk.Widget;
with Gtk.Dialog;     use Gtk.Dialog;
with Gtk.About_Dialog; use Gtk.About_Dialog;
with Gtk.Label;        use Gtk.Label;
with Ada.Text_IO; use Ada.Text_IO;
with address_spaces; 	use address_spaces;
with Address_Space_Set; 			use Address_Space_Set;
with buffers;			use buffers;
with buffer_set;			use buffer_set;
use Buffers.Buffer_Roles_Package;
with graphical_editor.user_message;    use graphical_editor.user_message;
with GNAT.Current_Exception;                               use GNAT.Current_Exception;
with Gtkada.Builder; use Gtkada.Builder;
with Gtk.Combo_Box; use Gtk.Combo_Box;
with Glib;      use Glib;
with Glib.Object; use Glib.Object;
with Processor_Set; 					use Processor_Set;
with Processors;                                           use Processors;
with Framework_Config;                                     use Framework_Config;
with Translate;                                            use Translate;
with Gtk.List_Store;   use Gtk.List_Store;
with Gtk.Tree_Model;  use Gtk.Tree_Model;
with Gtk.Tree_View;  use Gtk.Tree_View;
with Task_Set; 			use Task_Set;                                      
use Task_Set.Generic_Task_Set;
with Tasks;       use Tasks;
with gtk.tree_view_column; use gtk.tree_view_column;

package body graphical_editor.buffers is

buffer_table_length : constant natural :=10;

procedure Initialize_Buffer(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class) is 
	ob1: GObject:= Get_Object(Object, "textbuffer1");
	ob2: GObject:= Get_Object(Object, "combobox3");
	ob3: GObject:= Get_Object(Object, "textbuffer2");
	ob4: GObject:= Get_Object(Object, "combobox1");
	ob5: GObject:= Get_Object(Object, "combobox2");
	ob6: GObject:= Get_Object(Object, "liststore2");
	ob7: GObject:= Get_Object(Object, "treeview1");
	ob8: GObject:= Get_Object(Object, "liststore3");
	ob9: GObject:= Get_Object(Object, "treeview2");
	wid1: t_widget := (ptype => buffer_string, buffer_value => Gtk_Text_Buffer(ob1));
	wid2: t_widget := (ptype => combo, combo_value => Gtk_Combo_Box(ob2));
	wid3: t_widget := (ptype => buffer_integer, buffer_value => Gtk_Text_Buffer(ob3));
	wid4: t_widget := (ptype => combo, combo_value => Gtk_Combo_Box(ob4));
	wid5: t_widget := (ptype => combo, combo_value => Gtk_Combo_Box(ob5));
	wid6: t_widget := (ptype => lists, list_value => Gtk_List_Store(ob6));
	wid7: t_widget := (ptype => view, view_value => Gtk_Tree_View(ob7));
	wid8: t_widget := (ptype => lists, list_value => Gtk_List_Store(ob8));
	wid9: t_widget := (ptype => view, view_value => Gtk_Tree_View(ob9));
	wid10: t_widget := (ptype => window, window_value => Buffer_Window);

begin

	my_tab(1..buffer_table_length) := (new t_widget'(wid1), new t_widget'(wid2), new t_widget'(wid3), 
	new t_widget'(wid4), new t_widget'(wid5), new t_widget'(wid6), new t_widget'(wid7), 
	new t_widget'(wid8), new t_widget'(wid9), new t_widget'(wid10));

end initialize_Buffer;


procedure Check_Buffer(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class; Error_Message: in out Unbounded_String; Ok: in out Boolean) is 

	buffer_name, buffer_size_string, processor_name, address_space_name : Unbounded_String;
	buffer_size : integer;
	Integer_Ok      : Boolean;

begin
	buffer_name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));
	if (buffer_name = "") then
		Ok            := False;
            Error_Message := Lb_buffer_name_Mandatory (Current_Language);
            return;
         end if;

	buffer_size_string := get_value_buffer_string(Gtk_Text_Buffer(my_tab(3).buffer_value));
	if (buffer_size_string = "") then
		buffer_size := 0;
	else
		to_integer (buffer_size_string, buffer_size, Integer_Ok);
		if not Integer_Ok then
			Ok := False;
			Error_Message := "Size" & Lb_Must_Be_Numeric (Current_Language);
			return;
		end if;
	end if;

	processor_name := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(2).combo_value)));
	if (processor_name = "") then
		Ok  := False;
		Error_Message := Lb_processor_name_Mandatory (Current_Language);
		return;
	end if;

	address_space_name := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(5).combo_value)));
	if (address_space_name = "") then
		Ok  := False;
		Error_Message := Lb_address_space_name_Mandatory (Current_Language);
		return;
	end if;

	Check_Buffer (Sys.Buffers, buffer_name, buffer_size, processor_name, address_Space_Name);

	exception
	when Buffer_Set.Invalid_Parameter =>
	begin
		Ok := False;
		Error_Message := To_Unbounded_String (Exception_Message);
		return;
	end;

	when others =>
	begin
		Ok  := False;
		Error_Message := To_Unbounded_String (Exception_Name & Exception_Message);
		return;
	end;

end Check_Buffer;

procedure Add_In_Sys_Buffer(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class) is 
	buffer_name, processor_name, buffer_size_string, address_space_name, queing_system_string : Unbounded_String;
	queing_system: Queueing_Systems_Type;
	buffer_size, number_rows: Integer;
	Integer_Ok      : Boolean;
	
	Roles: Buffer_Roles_Table;
	task_name_value, buf_role_the_role_value, buf_role_size_value, buf_role_time_value, buf_role_timeout_value: GValue;
	A_Task: Generic_Task_Ptr;
	buf_role : Buffer_Role;
	tree_iter_inter: Gtk_Tree_Iter;
begin

	buffer_name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));
	processor_name := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(2).combo_value)));
	buffer_size_string := get_value_buffer_string(Gtk_Text_Buffer(my_tab(3).buffer_value));
	if (buffer_size_string = "") then
		buffer_size := 0;
	else
		to_integer (buffer_size_string, buffer_size, Integer_Ok);
	end if;
	address_space_name := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(5).combo_value)));
	queing_system_string := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(4).combo_value)));
	if (queing_system_string = "") then
		queing_system := get_compatible_queueing_system("Qs Pp1");
	end if;
	queing_system := get_compatible_queueing_system(Get_Active_Text(Gtk_Combo_Box(my_tab(4).combo_value)));

	--gerer l'ajout des roles ...
	number_rows:= get_number_elements(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(7).view_value)));
	tree_iter_inter := Get_Iter_First (Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(7).view_value)));
	for i in 1 .. number_rows loop
		Gtk.Tree_Model.Get_Value(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(7).view_value)), 
		tree_iter_inter, 0, task_name_value);
		A_task := Search_Task (sys.tasks, to_Unbounded_String(Get_String(task_name_value)));
		Gtk.Tree_Model.Get_Value(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(7).view_value)), 
		tree_iter_inter, 1, buf_role_size_value);
		buf_role.size := integer(Get_int(buf_role_size_value));
		Gtk.Tree_Model.Get_Value(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(7).view_value)), 
		tree_iter_inter, 2, buf_role_the_role_value);
		buf_role.the_role := get_compatible_role(buf_role_the_role_value);
		Gtk.Tree_Model.Get_Value(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(7).view_value)), 
		tree_iter_inter, 3, buf_role_time_value);
		buf_role.time := integer(Get_int(buf_role_time_value));
		Gtk.Tree_Model.Get_Value(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(7).view_value)), 
		tree_iter_inter, 4, buf_role_timeout_value);
		buf_role.timeout := integer(Get_int(buf_role_timeout_value));
		add (Roles, A_Task.name, buf_role);
		next(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(7).view_value)), tree_iter_inter); 
	end loop;

	Buffer_set.Add_Buffer (sys.Buffers, buffer_name, buffer_size, processor_Name, address_space_name, queing_system, Roles);

	exception
	when Buffer_set.Invalid_Parameter =>
	begin
		Show_Message_Box (Exception_Message);
		return;
	end;

	when others =>
	begin
		Show_Message_Box (Exception_Name & Exception_Message);
		return;
	end;

end Add_In_Sys_Buffer;

procedure Deleted_In_Sys_Buffer(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class) is 
	A_Buffer     : Buffer_Ptr;
	name: unbounded_string;
begin
	name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));
	A_Buffer := Search_Buffer (Sys.Buffers, name);
	Delete_Buffer (Sys, A_Buffer);

end Deleted_In_Sys_Buffer;

procedure Show_In_Sys_Buffer(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class) is 
	name : unbounded_string;
	A_Buffer : Buffer_Ptr;
	tree_iter: Gtk_Tree_Iter;
	liststore: GObject;
begin
	name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));
	A_Buffer := Search_Buffer (sys.Buffers, Name);

	liststore:= Get_Object(Object, "liststore2");
	Gtk.List_Store.Clear(Gtk_List_Store(liststore));
	for i in 0..A_Buffer.roles.nb_entries - 1 loop
		Append(Gtk_List_Store(liststore), tree_iter);
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 0, To_String (A_Buffer.roles.entries (i).item));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, Gint(A_Buffer.roles.entries (i).data.size));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 2, 
		To_string(get_compatible_role(A_Buffer.roles.entries (i).data.the_role)));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 3, Gint(A_Buffer.roles.entries (i).data.time));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 4, Gint(A_Buffer.roles.entries (i).data.timeout));
	end loop;

end Show_In_Sys_Buffer;

procedure Show_Lign_Buffer (Object : access Gtkada_Builder_Record'Class) is 
	tree_iter: Gtk_Tree_Iter;
	path1: Gtk_Tree_Path;
	focus1: Gtk_Tree_View_Column;
	combo_text, combo_text2: unbounded_string;
begin
	Get_Cursor(Gtk_Tree_View(get_object(object, "treeview1")), path1, focus1);
	if path1 /= null and focus1 /= null then 
		tree_iter:= get_iter(Gtk_Tree_Model(get_object(object, "liststore2")), path1);
		combo_text := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(get_object(object, "liststore2")), 
		tree_iter, 0));
		Set_Active(Gtk_Combo_Box(get_object(object, "combobox5")), 
		Gint(get_int_combo(Gtk_Combo_Box(get_object(object, "combobox5")), combo_text)));
		Set_Text(Gtk_Text_Buffer(get_object(object, "textbuffer3")), 
		integer'image(integer(Gtk.Tree_Model.Get_Int(Gtk_Tree_Model(get_object(object, "liststore2")), tree_iter, 1))));
		combo_text2 := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(get_object(object, "liststore2")), 
		tree_iter, 2));
		Set_Active(Gtk_Combo_Box(get_object(object, "combobox4")), 
		Gint(get_int_combo(Gtk_Combo_Box(get_object(object, "combobox4")), combo_text2)));
		Set_Text(Gtk_Text_Buffer(get_object(object, "textbuffer4")), 
		integer'image(integer(Gtk.Tree_Model.Get_Int(Gtk_Tree_Model(get_object(object, "liststore2")), tree_iter, 3))));
		Set_Text(Gtk_Text_Buffer(get_object(object, "textbuffer5")), 
		integer'image(integer(Gtk.Tree_Model.Get_Int(Gtk_Tree_Model(get_object(object, "liststore2")), tree_iter, 4))));
	end if;


end Show_Lign_Buffer;

procedure Add_View_buffer (Object : access Gtkada_Builder_Record'Class) is 
	tree_iter: Gtk_Tree_Iter;
begin
	Append(Gtk_List_Store(Get_Object(Object, "liststore2")), tree_iter);
	Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore2")), tree_iter, 0, 
	Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox5"))));
	Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore2")), tree_iter, 1, 
	Gint(get_value_buffer_integer(Gtk_Text_Buffer(Get_Object(Object, "textbuffer3")))));
	Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore2")), tree_iter, 2, 
	Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox4"))));
	Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore2")), tree_iter, 3, 
	Gint(get_value_buffer_integer(Gtk_Text_Buffer(Get_Object(Object, "textbuffer4")))));
	Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore2")), tree_iter, 4, 
	Gint(get_value_buffer_integer(Gtk_Text_Buffer(Get_Object(Object, "textbuffer5")))));
end Add_View_buffer;

procedure Delected_lign_buffer (Object : access Gtkada_Builder_Record'Class) is 
	liststore : Gobject;
	tree_iter: Gtk_Tree_Iter;
	path1: Gtk_Tree_Path;
	focus1: Gtk_Tree_View_Column;
begin
	liststore := get_object(object, "liststore2");
	Get_Cursor(Gtk_Tree_View(get_object(object, "treeview1")), path1, focus1);
	if path1 /= null and focus1 /= null then 
		tree_iter:= get_iter(Gtk_Tree_Model(liststore), path1);
		Gtk.List_Store.Remove(Gtk_List_Store(liststore), tree_iter);
		Set_Active(Gtk_Combo_Box(Get_Object(Object, "combobox5")), Gint(-1));
		Set_Text(Gtk_Text_Buffer(Get_Object(Object, "textbuffer3")), "");
		Set_Active(Gtk_Combo_Box(Get_Object(Object, "combobox4")), Gint(-1));
		Set_Text(Gtk_Text_Buffer(Get_Object(Object, "textbuffer4")), "");
		Set_Text(Gtk_Text_Buffer(Get_Object(Object, "textbuffer5")), "");
	end if;
end Delected_lign_buffer;

procedure Modify_View_buffer (Object : access Gtkada_Builder_Record'Class) is 
	
	liststore : Gobject;
	tree_iter: Gtk_Tree_Iter;
	path1: Gtk_Tree_Path;
	focus1: Gtk_Tree_View_Column;
begin
	liststore := get_object(object, "liststore2");
	Get_Cursor(Gtk_Tree_View(get_object(object, "treeview1")), path1, focus1);
	if path1 /= null and focus1 /= null then 
		tree_iter:= get_iter(Gtk_Tree_Model(liststore), path1);
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 0, 
			Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox5"))));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, 
			Gint(get_value_buffer_integer(Gtk_Text_Buffer(Get_Object(Object, "textbuffer3")))));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 2, 
			Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox4"))));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 3, 
			Gint(get_value_buffer_integer(Gtk_Text_Buffer(Get_Object(Object, "textbuffer4")))));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 4, 
			Gint(get_value_buffer_integer(Gtk_Text_Buffer(Get_Object(Object, "textbuffer5")))));
	end if;

end Modify_View_Buffer;

procedure Modify_In_Sys_Buffer(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class; name: unbounded_string) is 
	A_Buffer, A_Buffer_Buffer     : Buffer_Ptr;

	number_rows : integer;
	Roles: Buffer_Roles_Table;
	task_name_value, buf_role_the_role_value, buf_role_size_value, buf_role_time_value, buf_role_timeout_value: GValue;
	A_Task: Generic_Task_Ptr;
	buf_role : Buffer_Role;
	tree_iter_inter: Gtk_Tree_Iter;
begin
	A_Buffer := Search_Buffer (Sys.Buffers, name);
	A_Buffer_Buffer := A_Buffer;

	A_Buffer_Buffer.cheddar_private_id := A_Buffer.cheddar_private_id;
	A_Buffer_Buffer.name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));
	A_Buffer_Buffer.cpu_name := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(2).combo_value)));
	A_Buffer_Buffer.size := get_value_buffer_integer(Gtk_Text_Buffer(my_tab(3).buffer_value));
	A_Buffer_Buffer.queueing_system_type := get_compatible_queueing_system(Get_Active_Text(Gtk_Combo_Box(my_tab(4).combo_value)));
	A_Buffer_Buffer.address_space_name := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(5).combo_value)));

	Check_Buffer (Sys.Buffers, A_Buffer_Buffer.name, A_Buffer_Buffer.size, A_Buffer_Buffer.cpu_name, 
	A_Buffer_Buffer.address_space_name);
	Delete_Buffer (Sys, A_Buffer);

	number_rows:= get_number_elements(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(7).view_value)));
	tree_iter_inter := Get_Iter_First (Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(7).view_value)));
	for i in 1 .. number_rows loop
		Gtk.Tree_Model.Get_Value(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(7).view_value)), 
		tree_iter_inter, 0, task_name_value);
		A_task := Search_Task (sys.tasks, to_Unbounded_String(Get_String(task_name_value)));
		Gtk.Tree_Model.Get_Value(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(7).view_value)), 
		tree_iter_inter, 1, buf_role_size_value);
		buf_role.size := integer(Get_int(buf_role_size_value));
		Gtk.Tree_Model.Get_Value(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(7).view_value)), 
		tree_iter_inter, 2, buf_role_the_role_value);
		buf_role.the_role := get_compatible_role(buf_role_the_role_value);
		Gtk.Tree_Model.Get_Value(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(7).view_value)), 
		tree_iter_inter, 3, buf_role_time_value);
		buf_role.time := integer(Get_int(buf_role_time_value));
		Gtk.Tree_Model.Get_Value(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(7).view_value)), 
		tree_iter_inter, 4, buf_role_timeout_value);
		buf_role.timeout := integer(Get_int(buf_role_timeout_value));
		add (Roles, A_Task.name, buf_role);
		next(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(7).view_value)), tree_iter_inter); 
	end loop;

	Buffer_set.Add_Buffer (sys.Buffers, A_Buffer_Buffer.name, A_Buffer_Buffer.size, A_Buffer_Buffer.cpu_name, 
	A_Buffer_Buffer.address_space_name, A_Buffer_Buffer.queueing_system_type, Roles);


	exception
	when Buffer_set.Invalid_Parameter =>
	begin
		Show_Message_Box (Exception_Message);
		return;
	end;

	when others =>
	begin
		Show_Message_Box (Exception_Name & Exception_Message);
		return;
	end;
end Modify_In_Sys_Buffer;

function get_compatible_queueing_system(my_queueing_system: String) return Queueing_Systems_Type is 
	
	my_queueing_system_queing : Queueing_Systems_Type;

begin
	if to_Unbounded_String(my_queueing_system) = to_Unbounded_String("Qs Pp1") then
		my_queueing_system_queing := Qs_Pp1;
	end if;
	if to_Unbounded_String(my_queueing_system) = to_Unbounded_String("Qs Mm1") then
		my_queueing_system_queing := Qs_Mm1;
	end if;
	if to_Unbounded_String(my_queueing_system) = to_Unbounded_String("Qs Md1") then
		my_queueing_system_queing := Qs_Md1;
	end if;	
	if to_Unbounded_String(my_queueing_system) = to_Unbounded_String("Qs Mp1") then
		my_queueing_system_queing := Qs_Mp1;
	end if;
	if to_Unbounded_String(my_queueing_system) = to_Unbounded_String("Qs Mg1") then
		my_queueing_system_queing := Qs_Mg1;
	end if;
	if to_Unbounded_String(my_queueing_system) = to_Unbounded_String("Qs Mms") then
		my_queueing_system_queing := Qs_Mms;
	end if;
	if to_Unbounded_String(my_queueing_system) = to_Unbounded_String("Qs Mds") then
		my_queueing_system_queing := Qs_Mds;
	end if;
	if to_Unbounded_String(my_queueing_system) = to_Unbounded_String("Qs Mps") then
		my_queueing_system_queing := Qs_Mps;
	end if;
	if to_Unbounded_String(my_queueing_system) = to_Unbounded_String("Qs Mgs") then
		my_queueing_system_queing := Qs_Mgs;
	end if;
	if to_Unbounded_String(my_queueing_system) = to_Unbounded_String("Qs Mm1n") then
		my_queueing_system_queing := Qs_Mm1n;
	end if;
	if to_Unbounded_String(my_queueing_system) = to_Unbounded_String("Qs Md1n") then
		my_queueing_system_queing := Qs_Md1n;
	end if;
	if to_Unbounded_String(my_queueing_system) = to_Unbounded_String("Qs Mp1n") then
		my_queueing_system_queing := Qs_Mp1n;
	end if;
	if to_Unbounded_String(my_queueing_system) = to_Unbounded_String("Qs Mg1n") then
		my_queueing_system_queing := Qs_Mg1n;
	end if;
	if to_Unbounded_String(my_queueing_system) = to_Unbounded_String("Qs Mmsn") then
		my_queueing_system_queing := Qs_Mmsn;
	end if;
	if to_Unbounded_String(my_queueing_system) = to_Unbounded_String("Qs Mdsn") then
		my_queueing_system_queing := Qs_Mdsn;
	end if;
	if to_Unbounded_String(my_queueing_system) = to_Unbounded_String("Qs Mpsn") then
		my_queueing_system_queing := Qs_Mpsn;
	end if;
	if to_Unbounded_String(my_queueing_system) = to_Unbounded_String("Qs Mgsn") then
		my_queueing_system_queing := Qs_Mgsn;
	end if;
	return my_queueing_system_queing;
end get_compatible_queueing_system;


function get_compatible_queueing_system(my_queueing_system: Gvalue) return Queueing_Systems_Type is 

begin

	return get_compatible_queueing_system(Get_String(my_queueing_system));

end get_compatible_queueing_system;

function get_compatible_queueing_system(my_queueing_system: Queueing_Systems_Type) return unbounded_string is 
	my_queueing_system_string: unbounded_string;
begin
	if my_queueing_system = Qs_Pp1 then 
		my_queueing_system_string:= to_Unbounded_String("Qs Pp1");
	end if;
	if my_queueing_system = Qs_Mm1 then 
		my_queueing_system_string:= to_Unbounded_String("Qs Mm1");
	end if;
	if my_queueing_system = Qs_Md1 then 
		my_queueing_system_string:= to_Unbounded_String("Qs Md1");
	end if;
	if my_queueing_system = Qs_Mp1 then 
		my_queueing_system_string:= to_Unbounded_String("Qs Mp1");
	end if;
	if my_queueing_system = Qs_Mg1 then 
		my_queueing_system_string:= to_Unbounded_String("Qs Mg1");
	end if;
	if my_queueing_system = Qs_Mms then 
		my_queueing_system_string:= to_Unbounded_String("Qs Mms");
	end if;
	if my_queueing_system = Qs_Mds then 
		my_queueing_system_string:= to_Unbounded_String("Qs Mds");
	end if;
	if my_queueing_system = Qs_Mps then 
		my_queueing_system_string:= to_Unbounded_String("Qs Mps");
	end if;
	if my_queueing_system = Qs_Mgs then 
		my_queueing_system_string:= to_Unbounded_String("Qs Mgs");
	end if;
	if my_queueing_system = Qs_Mm1n then 
		my_queueing_system_string:= to_Unbounded_String("Qs Mm1n");
	end if;
	if my_queueing_system = Qs_Md1n then 
		my_queueing_system_string:= to_Unbounded_String("Qs Md1n");
	end if;
	if my_queueing_system = Qs_Mp1n then 
		my_queueing_system_string:= to_Unbounded_String("Qs Mp1n");
	end if;
	if my_queueing_system = Qs_Mg1n then 
		my_queueing_system_string:= to_Unbounded_String("Qs Mg1n");
	end if;
	if my_queueing_system = Qs_Mmsn then 
		my_queueing_system_string:= to_Unbounded_String("Qs Mmsn");
	end if;
	if my_queueing_system = Qs_Mdsn then 
		my_queueing_system_string:= to_Unbounded_String("Qs Mdsn");
	end if;
	if my_queueing_system = Qs_Mpsn then 
		my_queueing_system_string:= to_Unbounded_String("Qs Mpsn");
	end if;
	if my_queueing_system = Qs_Mgsn then 
		my_queueing_system_string:= to_Unbounded_String("Qs Mgsn");
	end if;
	return my_queueing_system_string;

end get_compatible_queueing_system;


function get_compatible_role(my_role: Gvalue) return Buffer_Role_Type is 

begin

	return get_compatible_role(Get_String(my_role));

end get_compatible_role;


function get_compatible_role(my_role: String) return Buffer_Role_Type is 
	my_role_role : Buffer_Role_Type;
begin
	if to_Unbounded_String(my_role) = to_Unbounded_String("No Role") then
		my_role_role := No_Role;
	end if;
	if to_Unbounded_String(my_role) = to_Unbounded_String("Queuing Producer") then
		my_role_role := Queuing_Producer;
	end if;
	if to_Unbounded_String(my_role) = to_Unbounded_String("Queuing Consumer") then
		my_role_role := Queuing_Consumer;
	end if;
	if to_Unbounded_String(my_role) = to_Unbounded_String("Sampling Writer") then
		my_role_role := Sampling_Writer;
	end if;
	if to_Unbounded_String(my_role) = to_Unbounded_String("Sampling Reader") then
		my_role_role := Sampling_Reader;
	end if;
	return my_role_role;
end get_compatible_role;

function get_compatible_role(my_role: Buffer_Role_Type) return unbounded_string is 
	my_role_string: unbounded_string;
begin
	if my_role = No_Role then 
		my_role_string:= to_Unbounded_String("No Role");
	end if;
	if my_role = Queuing_Producer then 
		my_role_string:= to_Unbounded_String("Queuing Producer");
	end if;
	if my_role = Queuing_Consumer then 
		my_role_string:= to_Unbounded_String("Queuing Consumer");
	end if;
	if my_role = Sampling_Writer then 
		my_role_string:= to_Unbounded_String("Sampling Writer");
	end if;
	if my_role = Sampling_Reader then 
		my_role_string:= to_Unbounded_String("Sampling Reader");
	end if;
	return my_role_string;
end get_compatible_role;


package buffer_callbacks is new generic_callbacks(Number_of_widget => buffer_table_length, Initialize => initialize_buffer, 
	Check => Check_buffer, Add_In_Sys => Add_In_Sys_Buffer, Deleted_In_Sys => Deleted_In_Sys_Buffer, 
	Modify_In_Sys => Modify_In_Sys_Buffer, Show_In_Sys => Show_In_Sys_Buffer);  use buffer_callbacks;

procedure Show_Buffer_Widget is

	Builder : Gtkada_Builder;
	Error   : Glib.Error.GError;

	My_Iterator : buffers_Iterator;
	A_Buffer : Buffer_Ptr;
	tree_iter: Gtk_Tree_Iter;
	liststore: GObject; 

	A_Processor : Generic_Processor_Ptr;
	My_Processor_Iterator : Processors_Iterator;
	my_combo_cpu: GObject;

	An_Adress_Space : Address_Space_Ptr;
	My_Adress_Space_Iterator : Address_Spaces_Iterator;
	my_combo_adress_space: GObject;

	A_Task : Generic_Task_Ptr;
	My_Task_Iterator : Tasks_Iterator;
	my_combo1: GObject;

begin
	Gtk.Main.Init;
	Gtk_New (Builder);
	Error := Add_From_File (Builder, to_string(Glade_path) & "buffer.glade");
	if Error /= null then
		Ada.Text_IO.Put_Line ("Error : " & Get_Message (Error));
		Error_Free (Error);
		return;
	end if;

	Sys_buffer := sys;

	my_combo1 := Get_Object(Builder, "combobox5");
	reset_iterator (sys.Tasks, My_Task_Iterator);
	if not is_empty (sys.Tasks) then 
	loop
		current_element (sys.Tasks, A_Task, My_Task_Iterator);
		Append_Text (Gtk_Combo_Box(my_combo1), To_String(A_Task.name));
		exit when is_last_element (sys.Tasks, My_Task_Iterator);
		next_element (sys.Tasks, My_Task_Iterator);
	end loop;
	else
		Show_Message_Box (Lb_Define_Tasks_Before (Current_Language));
	end if;


	my_combo_cpu := Get_Object(Builder, "combobox3");
	reset_iterator (sys.Processors, My_Processor_Iterator);
	if not is_empty (sys.Processors) then 
	loop
	current_element (sys.Processors, A_Processor, My_Processor_Iterator);
	Append_Text (Gtk_Combo_Box(my_combo_cpu), To_String(A_Processor.name));
	exit when is_last_element (sys.Processors, My_Processor_Iterator);
		next_element (sys.Processors, My_Processor_Iterator);
	end loop;
	else
	Show_Message_Box
	(Lb_Define_processors_Before (Current_Language));
	end if;

	my_combo_adress_space := Get_Object(Builder, "combobox2");
	reset_iterator (sys.Address_Spaces, My_Adress_Space_Iterator);
	if not is_empty (sys.Address_Spaces) then 
	loop
	current_element (sys.Address_Spaces, An_Adress_Space, My_Adress_Space_Iterator);
	Append_Text (Gtk_Combo_Box(my_combo_adress_space), To_String(An_Adress_Space.name));
	exit when is_last_element (sys.Address_Spaces, My_Adress_Space_Iterator);
		next_element (sys.Address_Spaces, My_Adress_Space_Iterator);
	end loop;
	else
	Show_Message_Box
	(Lb_Define_Address_Spaces_Before (Current_Language));
	end if;

	Set_Active (Gtk_Combo_Box(Get_Object(Builder, "combobox1")), 0);

	liststore:= Get_Object(Builder, "liststore3");
	reset_iterator (sys.Buffers, My_Iterator);

	if not is_empty (sys.Buffers) then
		loop
			current_element (sys.Buffers, A_Buffer, My_Iterator);
			Append(Gtk_List_Store(liststore), tree_iter);
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 0, To_String (A_Buffer.name));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, To_String (A_Buffer.cpu_name));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 2, Gint(A_Buffer.size));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 3, 
			To_String (get_compatible_queueing_system(A_Buffer.queueing_system_type)));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 4, 
			To_String (A_Buffer.address_space_name));			
			exit when is_last_element (sys.Buffers, My_Iterator);
			next_element (sys.Buffers, My_Iterator);
		end loop;
	end if;

	Gtkada.Builder.Register_Handler
		(Builder      => Builder,
		Handler_Name => "on_button1_clicked", 
		Handler      => buffer_callbacks.Close_View'Access);

	Gtkada.Builder.Register_Handler
		(Builder      => Builder,
		Handler_Name => "on_button8_clicked", 
		Handler      => Modify_View_Buffer'Access);

	Gtkada.Builder.Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button2_clicked", 
	Handler      => buffer_callbacks.Cancel_View'Access);

	Gtkada.Builder.Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button4_clicked", 
	Handler      => buffer_callbacks.Delected_Lign_Selected'Access); 

	Gtkada.Builder.Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button5_clicked", 
	Handler      => buffer_callbacks.Modify_Lign'Access); 

	Gtkada.Builder.Register_Handler
		(Builder      => Builder,
		Handler_Name => "on_button6_clicked", 
		Handler      => buffer_callbacks.Add_View'Access); 

	Gtkada.Builder.Register_Handler
		(Builder      => Builder,
		Handler_Name => "on_button9_clicked", 
		Handler      => Delected_lign_buffer'Access); 

	Gtkada.Builder.Register_Handler
		(Builder      => Builder,
		Handler_Name => "on_button7_clicked", 
		Handler      => Add_View_buffer'Access);

	Gtkada.Builder.Register_Handler
		(Builder      => Builder,
		Handler_Name => "on_treeview2_cursor_changed", 
		Handler      => buffer_callbacks.Show_Lign_Selected'Access);

	Gtkada.Builder.Register_Handler
		(Builder      => Builder,
		Handler_Name => "on_treeview1_cursor_changed", 
		Handler      => Show_Lign_Buffer'Access);

	Do_Connect (Builder);
	Gtk.Widget.Show_All (Get_Widget (Builder, "window1"));
	Gtk.Main.Main;
	Unref (Builder);

end Show_Buffer_Widget;

end graphical_editor.buffers;