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;
with Gtk.Tree_View_Column;  use Gtk.Tree_View_Column;
with Gtkada.Builder; use Gtkada.Builder;
with Glib.Values; use Glib.Values;
with Glib; use Glib;
with Glib.Object; use Glib.Object;
with Task_Set; 			use Task_Set;                                      
use Task_Set.Generic_Task_Set;
with Tasks;       use Tasks;
with graphical_editor.user_message;    use graphical_editor.user_message;  
with Gtk.Combo_Box; use Gtk.Combo_Box;
with Gtk.Tree_Model;  use Gtk.Tree_Model;
with Gtk.Text_Buffer; use Gtk.Text_Buffer;
with Gtk.Text_Iter;    use Gtk.Text_Iter;
with Gtk.List_Store;   use Gtk.List_Store;
with Framework_Config;                                     use Framework_Config;     
with Translate;                                            use Translate; 
with Processors;                                           use Processors;  
with Processors.extended;                                  use Processors.extended;   
with Processor_Set;    use Processor_Set;  
with address_spaces; 	use address_spaces;  
with Address_Space_Set; 			use Address_Space_Set;   
with Resources;                                           use Resources; 
with Resource_Set;    use Resource_Set;  
use Resource_Set.Generic_Resource_Set;
use Resources.Resource_Accesses;
with Gtk.Tree_View;  use Gtk.Tree_View;   
with GNAT.Current_Exception;                               use GNAT.Current_Exception;
with Ada.Text_IO; use Ada.Text_IO;               

package body graphical_editor.resources is

procedure Initialize_Resource(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, "textbuffer2");
	ob3: GObject:= Get_Object(Object, "textbuffer3");
	ob4: GObject:= Get_Object(Object, "textbuffer4");
	ob5: GObject:= Get_Object(Object, "combobox1");
	ob6: GObject:= Get_Object(Object, "combobox2");
	ob7: GObject:= Get_Object(Object, "combobox3");
	ob13: GObject:= Get_Object(Object, "textbuffer8");
	ob14: GObject:= Get_Object(Object, "combobox5");
	ob8: GObject:= Get_Object(Object, "liststore2");
	ob9: GObject:= Get_Object(Object, "treeview2");
	ob10: GObject:= Get_Object(Object, "liststore6");
	ob11: GObject:= Get_Object(Object, "treeview1");
	wid1: t_widget := (ptype => buffer_string, buffer_value => Gtk_Text_Buffer(ob1));
	wid2: t_widget := (ptype => buffer_integer, buffer_value => Gtk_Text_Buffer(ob2));
	wid3: t_widget := (ptype => buffer_integer, buffer_value => Gtk_Text_Buffer(ob3));
	wid4: t_widget := (ptype => buffer_integer, buffer_value => Gtk_Text_Buffer(ob4));
	wid5: t_widget := (ptype => combo, combo_value => Gtk_Combo_Box(ob5));
	wid6: t_widget := (ptype => combo, combo_value => Gtk_Combo_Box(ob6));
	wid7: t_widget := (ptype => combo, combo_value => Gtk_Combo_Box(ob7));
	wid13: t_widget := (ptype => buffer_integer, buffer_value => Gtk_Text_Buffer(ob13));
	wid14: t_widget := (ptype => combo, combo_value => Gtk_Combo_Box(ob14));
	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 => lists, list_value => Gtk_List_Store(ob10));
	wid11: t_widget := (ptype => view, view_value => Gtk_Tree_View(ob11));
	wid12: t_widget := (ptype => window, window_value => resource_window);

begin

	my_tab(1..resource_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'(wid13), new t_widget'(wid14), 
	new t_widget'(wid8), new t_widget'(wid9), new t_widget'(wid10), 
	new t_widget'(wid11), new t_widget'(wid12));

end initialize_Resource;

procedure Add_In_Sys_Resource(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class) is 

	Affected_Tasks : Resource_accesses_Table;
	Resource_name, Cpu_Name, Address_Space_Name, State_String, address_String, Size_String, priority_string : Unbounded_String;
	State, address, size, number_rows, resource_priority : integer;
	Protocol : Resources_Type;
	priority_assignment : Priority_Assignment_Type;
	Integer_Ok      : Boolean;
	my_critical_sec : Critical_Section;
	tree_iter_inter: Gtk_Tree_Iter;
	task_name_value, critical_begin_name_value, critical_end_name_value: GValue;
	A_Task: Generic_Task_Ptr;

begin

	Resource_name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));
	State_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(2).buffer_value));
	if State_String = "" then
		State := 0;
	else
		to_integer (State_String,State, Integer_Ok);
	end if;
	address_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(4).buffer_value));
	if address_String = "" then
		address := 0;
	else
		to_integer (address_String, address, Integer_Ok);
	end if;
	Size_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(3).buffer_value));
	if Size_String = "" then
		Size := 0;
	else
		to_integer (Size_String, Size, Integer_Ok);
	end if;
	Cpu_Name := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(7).combo_value)));
	Address_Space_Name := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(6).combo_value)));
	protocol := get_compatible_protocol(Get_Active_Text(Gtk_Combo_Box(my_tab(5).combo_value)));

	priority_string := get_value_buffer_string(Gtk_Text_Buffer(my_tab(8).buffer_value));
	if (priority_String = "") then
		resource_priority := 0;
	else 
		to_integer (priority_String, resource_priority, Integer_Ok);
	end if;

	priority_assignment := get_compatible_prirority_assignment(Get_Active_Text(Gtk_Combo_Box(my_tab(9).combo_value)));

	number_rows:= get_number_elements(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(11).view_value)));
	tree_iter_inter := Get_Iter_First (Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(11).view_value)));
	for i in 1 .. number_rows loop
		Gtk.Tree_Model.Get_Value(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(11).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(11).view_value)), 
		tree_iter_inter, 1, critical_begin_name_value);
		my_critical_sec.task_begin := integer(Get_int(critical_begin_name_value));
		Gtk.Tree_Model.Get_Value(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(11).view_value)), 
		tree_iter_inter, 2, critical_end_name_value);
		my_critical_sec.task_end := integer(Get_int(critical_end_name_value));
		add (Affected_Tasks, A_Task.name, my_critical_sec);
		next(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(11).view_value)), tree_iter_inter); 
	end loop;

	Add_Resource (sys.Resources, Resource_Name, State, address, size, Cpu_Name, Address_Space_Name, Protocol, 
	Affected_Tasks, resource_priority, priority_assignment);

	exception
	when resource_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_Resource;

procedure Deleted_In_Sys_Resource(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class) is 
	A_Resource      : Generic_Resource_Ptr;
	name: unbounded_string;
begin
	name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));
	A_Resource := Search_Resource (Sys.Resources, name);
	delete (Sys.Resources, A_Resource);
end Deleted_In_Sys_Resource;

procedure Show_In_Sys_Resource(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class) is 
	name, Processor_Name : unbounded_string;
	A_Resource      : Generic_Resource_Ptr;
	tree_iter: Gtk_Tree_Iter;
	liststore: GObject; 
begin
	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(7).combo_value)));
	A_Resource := Search_Resource (Sys.Resources, name);

	liststore:= Get_Object(Object, "liststore2");
	Gtk.List_Store.Clear(Gtk_List_Store(liststore));

	for i in 0..A_Resource.critical_sections.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_Resource.critical_sections.entries (i).item));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, 
		Gint(A_Resource.critical_sections.entries (i).data.task_begin));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 2, 
		Gint(A_Resource.critical_sections.entries (i).data.task_end));
	end loop;
end Show_In_Sys_Resource;

procedure Modify_In_Sys_Resource(my_tab: in out table_widget_id ; 
	Object : access Gtkada_Builder_Record'Class; name: unbounded_string) is 
	A_Resource, A_Resource_Buffer    : Generic_Resource_Ptr;
	Affected_Tasks : Resource_accesses_Table;
	my_critical_sec : Critical_Section;
	tree_iter_inter: Gtk_Tree_Iter;
	task_name_value, critical_begin_name_value, critical_end_name_value: GValue;
	A_Task: Generic_Task_Ptr;
	number_rows : integer;
begin
	A_Resource := Search_Resource (Sys.Resources, name);
	A_Resource_Buffer := A_Resource;

	A_Resource_Buffer.cheddar_private_id := A_Resource.cheddar_private_id;
	A_Resource_Buffer.name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));
	A_Resource_Buffer.state := get_value_buffer_integer(Gtk_Text_Buffer(my_tab(2).buffer_value));
	A_Resource_Buffer.size := get_value_buffer_integer(Gtk_Text_Buffer(my_tab(3).buffer_value));
	A_Resource_Buffer.address_space_name := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(6).combo_value)));
	A_Resource_Buffer.cpu_name := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(7).combo_value)));
	A_Resource_Buffer.address := get_value_buffer_integer(Gtk_Text_Buffer(my_tab(4).buffer_value));
	A_Resource_Buffer.protocol := get_compatible_protocol(Get_Active_Text(Gtk_Combo_Box(my_tab(5).combo_value)));
	A_Resource_Buffer.priority := Priority_Range'value(to_string(get_value_buffer_string(my_tab(8).buffer_value)));
	A_Resource_Buffer.priority_assignment := get_compatible_prirority_assignment(Get_Active_Text(Gtk_Combo_Box
	(my_tab(9).combo_value)));

	number_rows:= get_number_elements(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(11).view_value)));
	tree_iter_inter := Get_Iter_First (Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(11).view_value)));
	for i in 1 .. number_rows loop
		Gtk.Tree_Model.Get_Value(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(11).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(11).view_value)), 
		tree_iter_inter, 1, critical_begin_name_value);
		my_critical_sec.task_begin := integer(Get_int(critical_begin_name_value));
		Gtk.Tree_Model.Get_Value(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(11).view_value)), 
		tree_iter_inter, 2, critical_end_name_value);
		my_critical_sec.task_end := integer(Get_int(critical_end_name_value));
		add (Affected_Tasks, A_Task.name, my_critical_sec);
		next(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(11).view_value)), tree_iter_inter); 
	end loop;
	A_Resource_Buffer.critical_sections := Affected_Tasks;

	Check_Resource (Sys.Resources, A_Resource_Buffer.name, A_Resource_Buffer.state, A_Resource_Buffer.address, 
	A_Resource_Buffer.size, A_Resource_Buffer.cpu_name, A_Resource_Buffer.address_space_name, A_Resource_Buffer.protocol);
	delete (Sys.Resources, A_Resource);
	add(Sys.Resources, A_Resource_Buffer);

	exception
	when resource_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_Resource;

function get_compatible_protocol(myprotocol: Resources_Type) return unbounded_string is 
protocol_string: Unbounded_String;
begin
	if myprotocol = No_Protocol then 
			protocol_string:= to_Unbounded_String("Fifo");
	end if;

	if myprotocol = Priority_Ceiling_Protocol then 
			protocol_string:= to_Unbounded_String("Priority Ceiling Protocol");
	end if;

	if myprotocol = Priority_Inheritance_Protocol then 
			protocol_string:= to_Unbounded_String("Priority Inheritance Protocol");
	end if;

	if myprotocol = Immediate_Priority_Ceiling_Protocol then 
			protocol_string:= to_Unbounded_String("Immediate Priority Ceiling Protocol");
	end if;

return protocol_string;
end get_compatible_protocol;

function get_compatible_prirority_assignment(mypriorityassignment: Priority_Assignment_Type) return unbounded_string is 
mypriorityassignment_string: Unbounded_String;

begin
	if mypriorityassignment = Automatic_Assignment then 
			mypriorityassignment_string:= to_Unbounded_String("Automatic Assignment");
	end if;

	if mypriorityassignment = Manual_Assignment then 
			mypriorityassignment_string:= to_Unbounded_String("Manual Assignment");
	end if;

return mypriorityassignment_string;

end get_compatible_prirority_assignment;


function get_compatible_protocol(myprotocol: String) return Resources_Type is 

myprotocol_pro : Resources_Type;

begin
	if to_Unbounded_String(myprotocol) = to_Unbounded_String("Fifo") then
			myprotocol_pro := No_Protocol;
	end if;

	if to_Unbounded_String(myprotocol) = to_Unbounded_String("Priority Ceiling Protocol") then
			myprotocol_pro := Priority_Ceiling_Protocol;
	end if;

	if to_Unbounded_String(myprotocol) = to_Unbounded_String("Priority Inheritance Protocol") then
			myprotocol_pro := Priority_Inheritance_Protocol;
	end if;

	if to_Unbounded_String(myprotocol) = to_Unbounded_String("Immediate Priority Ceiling Protocol") then
			myprotocol_pro := Immediate_Priority_Ceiling_Protocol;
	end if;

	
	return myprotocol_pro;

end get_compatible_protocol;

function get_compatible_prirority_assignment(mypriorityassignment: String) return Priority_Assignment_Type is 

mypriorityassignment_pro : Priority_Assignment_Type;

begin
	if to_Unbounded_String(mypriorityassignment) = to_Unbounded_String("Automatic Assignment") then
			mypriorityassignment_pro := Automatic_Assignment;
	end if;

	if to_Unbounded_String(mypriorityassignment) = to_Unbounded_String("Manual Assignment") then
			mypriorityassignment_pro := Manual_Assignment;
	end if;

	return mypriorityassignment_pro;

end get_compatible_prirority_assignment;

procedure Check_Resource(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class; Error_Message: in out Unbounded_String; Ok: in out Boolean) is 
	Resource_name, Cpu_Name, Address_Space_Name, State_String, Size_String, address_string: Unbounded_String;
	Resource_State, address, size : integer;
	Protocol : Resources_Type;

begin

	Resource_name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));

	State_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(2).buffer_value));
	if State_String = "" then
		Resource_State := 0;
	else
		to_integer (State_String, Resource_State, Ok);
		if not Ok then
		Error_Message := Lb_Resource_State (Current_Language) & Lb_Must_Be_Numeric (Current_Language);
		return;
		end if;
	end if;

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

	address_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(4).buffer_value));
	if address_String = "" then
		address := 0;
	else
		to_integer (address_String, address, Ok);
		if not Ok then
		Error_Message := Lb_address (Current_Language) & Lb_Must_Be_Numeric (Current_Language);
		return;
		end if;
	end if;

	Cpu_Name := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(7).combo_value)));

	Address_Space_Name := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(6).combo_value)));

	protocol := get_compatible_protocol(Get_Active_Text(Gtk_Combo_Box(my_tab(5).combo_value)));

	Check_Resource (Sys.Resources, Resource_Name, Resource_State, address, size, Cpu_Name, Address_Space_Name, Protocol);


	exception

	when Resource_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_Message);

	end;

end Check_Resource;

function get_compatible_protocol(myprotocol: Gvalue) return resources_Type is 

begin
	return get_compatible_protocol(Get_String(myprotocol));

end get_compatible_protocol;

function get_compatible_prirority_assignment(mypriorityassignment: Gvalue) return Priority_Assignment_Type is 

begin
	return get_compatible_prirority_assignment(Get_String(mypriorityassignment));

end get_compatible_prirority_assignment;

procedure Show_Lign_Resource (Object : access Gtkada_Builder_Record'Class) is 
	tree_iter: Gtk_Tree_Iter;
	path1: Gtk_Tree_Path;
	focus1: Gtk_Tree_View_Column;
	combo_text: unbounded_string;
begin
	Get_Cursor(Gtk_Tree_View(get_object(object, "treeview2")), 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, "combobox4")), 
		Gint(get_int_combo(Gtk_Combo_Box(get_object(object, "combobox4")), combo_text)));
		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, 1))));
		Set_Text(Gtk_Text_Buffer(get_object(object, "textbuffer6")), 
		integer'image(integer(Gtk.Tree_Model.Get_Int(Gtk_Tree_Model(get_object(object, "liststore2")), tree_iter, 2))));
	end if;
end Show_Lign_Resource;

procedure Add_View_Task (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, "combobox4"))));
	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, "textbuffer5")))));
	Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore2")), tree_iter, 2, 
	Gint(get_value_buffer_integer(Gtk_Text_Buffer(Get_Object(Object, "textbuffer6")))));

end Add_View_Task;

procedure Delected_lign_view (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, "treeview2")), 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, "combobox4")), Gint(-1));
		Set_Text(Gtk_Text_Buffer(Get_Object(Object, "textbuffer5")), "");
		Set_Text(Gtk_Text_Buffer(Get_Object(Object, "textbuffer6")), "");
	end if;
end Delected_lign_view;

procedure Modify_lign_view (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, "treeview2")), 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, "combobox4"))));
	Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, 
	Gint(get_value_buffer_integer(Gtk_Text_Buffer(Get_Object(Object, "textbuffer5")))));
	Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 2, 
	Gint(get_value_buffer_integer(Gtk_Text_Buffer(Get_Object(Object, "textbuffer6")))));
	end if;
end Modify_lign_view;


procedure harmonize_comboxbox (Object : access Gtkada_Builder_Record'Class) is 
	Cpu_Name: unbounded_string;
	My_Iterator : Address_Spaces_Iterator;
	A_Addr      : Address_Space_Ptr;
	Result      : Address_Space_Ptr;
	Found : Boolean := False;
begin
	Cpu_Name := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox3"))));

	reset_iterator (sys.address_spaces, My_Iterator);
	loop
		current_element (sys.address_spaces, A_Addr, My_Iterator);
		if (A_Addr.cpu_name = Cpu_Name) then
			Found  := True;
			Result := A_Addr;
		end if;
		exit when is_last_element (sys.address_spaces, My_Iterator);
		next_element (sys.address_spaces, My_Iterator);
	end loop;

	Set_Active(Gtk_Combo_Box(Get_Object(Object, "combobox2")), 
	Gint(get_int_combo(Gtk_Combo_Box(Get_Object(Object, "combobox2")), result.name)));

end harmonize_comboxbox;

package resource_callbacks is new generic_callbacks(Number_of_widget => resource_table_length, Initialize => initialize_Resource, 
	Check => Check_Resource, Add_In_Sys => Add_In_Sys_Resource, Deleted_In_Sys => Deleted_In_Sys_Resource, 
	Modify_In_Sys => Modify_In_Sys_Resource, Show_In_Sys => Show_In_Sys_Resource);  use resource_callbacks;

procedure Show_Resource_Widget is
 
	Builder : Gtkada_Builder;
	Error   : Glib.Error.GError;

	tree_iter: Gtk_Tree_Iter;
	liststore: GObject; 
	A_Resource : Generic_Resource_Ptr;
	My_Iterator : Resources_Iterator;

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

	A_Cpu : Generic_Processor_Ptr;
	My_Cpu_Iterator : Processors_Iterator;
	my_combo_cpu: GObject;

	A_Adr : Address_Space_Ptr;
	My_Adr_Iterator : Address_Spaces_Iterator;
	my_combo_adr: GObject;

begin
	Gtk.Main.Init;
                         
	Gtk_New (Builder);
	Error := Add_From_File (Builder, to_string(Glade_path) & "resource.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, "combobox4");
	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_Cpu_Iterator);
	if not is_empty (sys.Processors) then 
	loop
	current_element (sys.Processors, A_Cpu, My_Cpu_Iterator);
	
	Append_Text (Gtk_Combo_Box(my_combo_cpu), To_String(A_Cpu.name));
	exit when is_last_element (sys.Processors, My_Cpu_Iterator);
		next_element (sys.Processors, My_Cpu_Iterator);
	end loop;
	else
	Show_Message_Box
	(Lb_Define_Processors_Before (Current_Language));
	end if;

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

	Set_Text (Gtk_Text_Buffer(Get_Object(Builder, "textbuffer8")), "0");
	Set_Active (Gtk_Combo_Box(Get_Object(Builder, "combobox5")), 0);
	Set_Active (Gtk_Combo_Box(Get_Object(Builder, "combobox1")), 0);

	liststore:= Get_Object(Builder, "liststore6");
	reset_iterator (sys.Resources, My_Iterator);
	if not is_empty (sys.Resources) then
		loop
		current_element (sys.Resources, A_Resource, My_Iterator);
		Append(Gtk_List_Store(liststore), tree_iter);
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 0, To_String (A_Resource.name));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, Gint(A_Resource.state));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 2, Gint(A_Resource.size));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 5, To_String (A_Resource.address_space_name));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 6, To_String (A_Resource.cpu_name));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 7, Gint (A_Resource.priority));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 8, 
		To_String (get_compatible_prirority_assignment(A_Resource.priority_assignment)));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 3, Gint(A_Resource.address)); 
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 4, To_String(get_compatible_protocol(A_Resource.protocol)));
		exit when is_last_element (sys.Resources, My_Iterator);
	next_element (sys.Resources, My_Iterator);
	         end loop;
	end if;

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

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

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

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

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

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

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

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

	Gtkada.Builder.Register_Handler
		(Builder      => Builder,
		Handler_Name => "on_button3_clicked", 
		Handler      => Delected_Lign_View'Access); 

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

	Gtkada.Builder.Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_combobox3_changed", 
	Handler      => harmonize_comboxbox'Access);

	Do_Connect (Builder);

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

end graphical_editor.resources;