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 Glib.Object;	use Glib.Object;
with Gtk.Text_Buffer;	use Gtk.Text_Buffer;
with Gtk.Combo_Box;	use Gtk.Combo_Box;
with Gtk.Text_Iter;	use Gtk.Text_Iter;
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 Gtk.Tree_View_Column;  use Gtk.Tree_View_Column;
with Glib;      use Glib;
with Glib.Object;	use Glib.Object;
with Glib.Values;	use Glib.Values;
with Ada.Text_IO;	use Ada.Text_IO;
with Ada.Strings.Unbounded;	use Ada.Strings.Unbounded;
with unbounded_strings;     use unbounded_strings;
with Processors;	use Processors;
with address_spaces;	use address_spaces;
with Processors.extended;	use Processors.extended;
with unbounded_strings;		use unbounded_strings;
use unbounded_strings.strings_table_package;
with Framework_Config;                                     use Framework_Config;
with Buffer_Set;                                           use Buffer_Set;
use Buffer_Set.Generic_Buffer_Set;
with Resource_Set;                                         use Resource_Set;
use Resource_Set.Generic_Resource_Set;
with graphical_editor.user_message;    use graphical_editor.user_message;
with GNAT.Current_Exception;                               use GNAT.Current_Exception;
with Translate;                                            use Translate;
with Networks;  			use Networks;
with Task_Set; 			use Task_Set;                                       
use Task_Set.Generic_Task_Set;
with Scheduler;                                            use Scheduler;
with Scheduler.user_defined.interpreted.pipeline;  use  Scheduler.user_defined.interpreted.pipeline;
with Scheduler.user_defined.interpreted.Automata;  use  Scheduler.user_defined.interpreted.Automata;
with Scheduler_Interface;                                  use Scheduler_Interface;
with Processor_Set; 					use Processor_Set;
with Address_Space_Set; 			use Address_Space_Set;
with Tasks;                                             use Tasks;
with Gtkada.Builder; use Gtkada.Builder;
with Glib;      use Glib;
with gdk.event; use gdk.event;
with offsets; use offsets;
use offsets.Offsets_Table_Package;

package body graphical_editor.tasks is

procedure Initialize_Task(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, "combobox1");
	ob3: GObject:= Get_Object(Object, "combobox3");
	ob4: GObject:= Get_Object(Object, "combobox2");
	ob5: GObject:= Get_Object(Object, "textbuffer2");
	ob6: GObject:= Get_Object(Object, "textbuffer3");
	ob7: GObject:= Get_Object(Object, "textbuffer4");
	ob8: GObject:= Get_Object(Object, "textbuffer12");
	ob9: GObject:= Get_Object(Object, "textbuffer5");
	ob10: GObject:= Get_Object(Object, "combobox5");
	ob11: GObject:= Get_Object(Object, "textbuffer6");
	ob12: GObject:= Get_Object(Object, "textbuffer7");
	ob13: GObject:= Get_Object(Object, "textbuffer8");
	ob14: GObject:= Get_Object(Object, "textbuffer9");
	ob15: GObject:= Get_Object(Object, "textbuffer10");
	ob16: GObject:= Get_Object(Object, "textbuffer11");
	ob17: GObject:= Get_Object(Object, "combobox7");
	ob18: GObject:= Get_Object(Object, "textbuffer15");
	ob19: GObject:= Get_Object(Object, "textbuffer16");
	ob20: GObject:= Get_Object(Object, "liststore7");
	ob21: GObject:= Get_Object(Object, "treeview2");
	ob22: GObject:= Get_Object(Object, "liststore8");
	ob23: GObject:= Get_Object(Object, "treeview3");
	ob24: GObject:= Get_Object(Object, "liststore4");
	ob25: GObject:= Get_Object(Object, "treeview1");
	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 => combo, combo_value => Gtk_Combo_Box(ob3));
	wid4: t_widget := (ptype => combo, combo_value => Gtk_Combo_Box(ob4));
	wid5: t_widget := (ptype => buffer_integer, buffer_value => Gtk_Text_Buffer(ob5));
	wid6: t_widget := (ptype => buffer_integer, buffer_value => Gtk_Text_Buffer(ob6));
	wid7: t_widget := (ptype => buffer_integer, buffer_value => Gtk_Text_Buffer(ob7));
	wid8: t_widget := (ptype => buffer_integer, buffer_value => Gtk_Text_Buffer(ob8));
	wid9: t_widget := (ptype => buffer_integer, buffer_value => Gtk_Text_Buffer(ob9));
	wid10: t_widget := (ptype => combo, combo_value => Gtk_Combo_Box(ob10));
	wid11: t_widget := (ptype => buffer_integer, buffer_value => Gtk_Text_Buffer(ob11));
	wid12: t_widget := (ptype => buffer_integer, buffer_value => Gtk_Text_Buffer(ob12));
	wid13: t_widget := (ptype => buffer_integer, buffer_value => Gtk_Text_Buffer(ob13));
	wid14: t_widget := (ptype => buffer_integer, buffer_value => Gtk_Text_Buffer(ob14));
	wid15: t_widget := (ptype => buffer_integer, buffer_value => Gtk_Text_Buffer(ob15));
	wid16: t_widget := (ptype => buffer_string, buffer_value => Gtk_Text_Buffer(ob16));
	wid17: t_widget := (ptype => combo, combo_value => Gtk_Combo_Box(ob17));
	wid18: t_widget := (ptype => buffer_integer, buffer_value => Gtk_Text_Buffer(ob18));
	wid19: t_widget := (ptype => buffer_integer, buffer_value => Gtk_Text_Buffer(ob19));
	wid20: t_widget := (ptype => lists, list_value => Gtk_List_Store(ob20));
	wid21: t_widget := (ptype => view, view_value => Gtk_Tree_View(ob21));
	wid22: t_widget := (ptype => lists, list_value => Gtk_List_Store(ob22));
	wid23: t_widget := (ptype => view, view_value => Gtk_Tree_View(ob23));
	wid24: t_widget := (ptype => lists, list_value => Gtk_List_Store(ob24));
	wid25: t_widget := (ptype => view, view_value => Gtk_Tree_View(ob25));
	wid26: t_widget := (ptype => window, window_value => Tasks_Window);

begin

	my_tab(1..task_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), 
	new t_widget'(wid11), new t_widget'(wid12), new t_widget'(wid13), new t_widget'(wid14), new t_widget'(wid15), 
	new t_widget'(wid16), new t_widget'(wid17), new t_widget'(wid18), new t_widget'(wid19), new t_widget'(wid20), 
	new t_widget'(wid21), new t_widget'(wid22), new t_widget'(wid23), new t_widget'(wid24), new t_widget'(wid25), 
	new t_widget'(wid26));

end initialize_Task;

procedure Check_Task(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class; 
	Error_Message: in out Unbounded_String; Ok: in out Boolean) is 
	task_name, Cpu_Name, Address_Space_Name, Start_Time_string, task_type_string, Capacity_string, Period_string, 
	Deadline_string, Jitter_string, Blocking_Time_string, Priority_task_string, Criticality_string, 
	Policy_string: Unbounded_String;
	Task_Type : Tasks_Type;
	Start_Time, Capacity, Period, Deadline, Jitter, Blocking_Time, Priority_task, Criticality : Integer;
	Policy : Policies;
	Integer_Ok  : Boolean;

begin

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

	Cpu_Name := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(3).combo_value)));
	if (Cpu_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(4).combo_value)));
	if (Address_Space_Name = "") then
		Ok := False;
		Error_Message := Lb_Address_Space_Name_Mandatory (Current_Language);
		return;
	end if;

	task_type_string := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(2).combo_value)));
	if (task_type_string = "") then
		Ok            := False;
		Error_Message := Lb_task_type_Mandatory (Current_Language);
		return;
         end if;
	task_type := get_compatible_task(Get_Active_Text(Gtk_Combo_Box(my_tab(2).combo_value)));
	
	Start_Time_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(7).buffer_value));
	if (Start_Time_String = "") then
		Start_Time := 0;
	else
		to_integer (Start_Time_String, Start_Time, Integer_Ok);
		if not Integer_Ok then
			Error_Message := Lb_Start_Time (Current_Language) & Lb_Must_Be_Numeric (Current_Language);
			Ok := False;
			return;
		end if;
	end if;

	Capacity_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(5).buffer_value));
	if (Capacity_String = "") then
		Capacity := 0;
	else
		to_integer (Capacity_String, Capacity, Integer_Ok);
		if not Integer_Ok then
			Error_Message := Lb_Capacity (Current_Language) & Lb_Must_Be_Numeric (Current_Language);
			Ok := False;
			return;
		end if;
	end if;

	Period_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(15).buffer_value));
	if (Period_String = "") then
		Period := 0;
	else
		to_integer (Period_String, Period, Integer_Ok);
		if not Integer_Ok then
			Error_Message := Lb_Period (Current_Language) & Lb_Must_Be_Numeric (Current_Language);
			Ok := False;
			return;
		end if;
	end if;

	Deadline_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(6).buffer_value));
	if (Deadline_String = "") then
		Deadline := 0;
	else
		to_integer (Deadline_String, Deadline, Integer_Ok);
		if not Integer_Ok then
			Error_Message := Lb_Deadline (Current_Language) & Lb_Must_Be_Numeric (Current_Language);
			Ok := False;
			return;
		end if;
	end if;

	Jitter_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(14).buffer_value));
	if (Jitter_String = "") then
		Jitter := 0;
	else
		to_integer (Jitter_String, Jitter, Integer_Ok);
		if not Integer_Ok then
			Error_Message := Lb_Jitter (Current_Language) & Lb_Must_Be_Numeric (Current_Language);
			Ok := False;
			return;
		end if;
	end if;

	Blocking_Time_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(9).buffer_value));
	if (Blocking_Time_String = "") then
		Blocking_Time := 0;
	else
		to_integer (Blocking_Time_String, Blocking_Time, Integer_Ok);
		if not Integer_Ok then
			Error_Message := Lb_Blocking_Time (Current_Language) & Lb_Must_Be_Numeric (Current_Language);
			Ok := False;
			return;
		end if;
	end if;

	Criticality_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(13).buffer_value));
	if (Criticality_String = "") then
		Criticality := 0;
	else
		to_integer (Criticality_String, Criticality, Integer_Ok);
		if not Integer_Ok then
			Error_Message := Lb_Criticality (Current_Language) & Lb_Must_Be_Numeric (Current_Language);
			Ok := False;
			return;
		end if;
	end if;

	--Priority_task_string := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(8).combo_value)));
	--if (Priority_task_string = "") then
        --	Ok := False;
	--	Error_Message := Lb_priority_Mandatory (Current_Language);
	--	return;
	--end if;
	--Priority_task := Integer'value(Get_Active_Text(Gtk_Combo_Box(my_tab(8).combo_value)));

	Priority_task_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(8).buffer_value));
	if (Priority_task_String = "") then
		Priority_task := 0;
	else
		to_integer (Priority_task_String, Priority_task, Integer_Ok);
		if not Integer_Ok then
			Error_Message := Lb_priority (Current_Language) & Lb_Must_Be_Numeric (Current_Language);
			Ok := False;
			return;
		end if;
	end if;

	Policy_string := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(10).combo_value)));
	if (Policy_string = "") then
        	Ok := False;
		Error_Message := Lb_Policy_Mandatory (Current_Language);
		return;
	end if;
	Policy := get_compatible_policy(Get_Active_Text(Gtk_Combo_Box(my_tab(10).combo_value)));

	Check_Task (sys.tasks, task_name, Cpu_Name, Address_Space_Name, Task_Type, Start_Time , Capacity, Period, 
	Deadline, Jitter, Blocking_Time, Priority_task, Criticality , Policy);
      --Offset                  : in Offsets_Table                 := No_Offset;
      --Stack_Memory_Size       : in Integer                       := 0;
      --Text_Memory_Size        : in Integer                       := 0;
      --Param                   : in User_Defined_Parameters_Table :=
     --No_User_Defined_Parameter;
     -- Parametric_Rule_Name    : in Unbounded_String              :=
     --empty_string;
      --Seed_Value              : in Integer                       := 0;
      --Predictable             : in Boolean                       := True;
      --context_switch_overhead : in Integer                       := 0);

	   exception
      when others =>
         Ok            := False;
         Error_Message := To_Unbounded_String (Exception_Message);
end Check_Task;

procedure Add_In_Sys_Task(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class) is 
	task_name, Cpu_Name, Address_Space_Name, Start_Time_String, Capacity_String, Period_string, Deadline_string, 
	Jitter_string, Blocking_Time_string, Criticality_string, Policy_string, Priority_task_String: Unbounded_String;
	Task_Type : Tasks_Type;
	Start_Time, Capacity, Period, Deadline, Jitter, Blocking_Time, Priority_task, Criticality : Integer;
	Policy : Policies;
	Integer_Ok      : Boolean;
begin

	task_name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));
	Cpu_Name := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(3).combo_value)));
	Address_Space_Name := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(4).combo_value)));
	task_type := get_compatible_task(Get_Active_Text(Gtk_Combo_Box(my_tab(2).combo_value)));

	Start_Time_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(7).buffer_value));
	if (Start_Time_String = "") then
		Start_Time := 0;
	else
		to_integer (Start_Time_String, Start_Time, Integer_Ok);
	end if;

	Capacity_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(5).buffer_value));
	if (Capacity_String = "") then
		Capacity := 0;
	else
		to_integer (Capacity_String, Capacity, Integer_Ok);
	end if;

	Period_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(15).buffer_value));
	if (Period_String = "") then
		Period := 0;
	else
		to_integer (Period_String, Period, Integer_Ok);
	end if;

	Deadline_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(6).buffer_value));
	if (Deadline_String = "") then
		Deadline := 0;
	else
		to_integer (Deadline_String, Deadline, Integer_Ok);
	end if;

	Jitter_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(14).buffer_value));
	if (Jitter_String = "") then
		Jitter := 0;
	else
		to_integer (Jitter_String, Jitter, Integer_Ok);
	end if;

	Blocking_Time_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(9).buffer_value));
	if (Blocking_Time_String = "") then
		Blocking_Time := 0;
	else
		to_integer (Blocking_Time_String, Blocking_Time, Integer_Ok);
	end if;

	Criticality_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(13).buffer_value));
	if (Criticality_String = "") then
		Criticality := 0;
	else
		to_integer (Criticality_String, Criticality, Integer_Ok);
	end if;

	--Priority_task := Integer'value(Get_Active_Text(Gtk_Combo_Box(my_tab(8).combo_value)));

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

	--Policy := Policies'value(Get_Active_Text(Gtk_Combo_Box(my_tab(10).combo_value)));
	policy := get_compatible_policy(Get_Active_Text(Gtk_Combo_Box(my_tab(10).combo_value)));

	Add_Task (sys.tasks, task_name, Cpu_Name, Address_Space_Name, Task_Type, Start_Time , Capacity, Period, 
	Deadline, Jitter, Blocking_Time, Priority_task, Criticality , Policy);
      --Offset                  : in Offsets_Table                 := No_Offset;
      --Stack_Memory_Size       : in Integer                       := 0;
      --Text_Memory_Size        : in Integer                       := 0;
      --Param                   : in User_Defined_Parameters_Table :=
     --No_User_Defined_Parameter;
     -- Parametric_Rule_Name    : in Unbounded_String              :=
     --empty_string;
      --Seed_Value              : in Integer                       := 0;
      --Predictable             : in Boolean                       := True;
      --context_switch_overhead : in Integer                       := 0);

	exception
	
	when Task_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_Task;

function get_compatible_policy(mypolicy: Gvalue) return Policies is 
begin
	return get_compatible_policy(Get_String(mypolicy));
end get_compatible_policy;

function get_compatible_predictable(mypredictable: Gvalue) return boolean is 
begin
	return get_compatible_predictable(Get_String(mypredictable));
end get_compatible_predictable;

function get_compatible_policy(mypolicy: Policies) return unbounded_string is 
mypolicy_string: unbounded_string;
begin
	if mypolicy = Sched_Fifo then 
			mypolicy_string:= to_Unbounded_String("Sched Fifo");
	end if;

	if mypolicy = Sched_Rr then 
			mypolicy_string:= to_Unbounded_String("Sched Rr");
	end if;

	if mypolicy = Sched_Others then 
			mypolicy_string:= to_Unbounded_String("Sched Others");
	end if;

	return mypolicy_string;

end get_compatible_policy;

function get_compatible_predictable(mypredictable: boolean) return unbounded_string is 
	mypredictable_string: unbounded_string := to_unbounded_string("False");
begin
	if mypredictable = True or mypredictable = true then 
			mypredictable_string:= to_Unbounded_String("True");
	end if;
	if mypredictable = False or mypredictable = false then 
			mypredictable_string:= to_Unbounded_String("False");
	end if;
	return mypredictable_string;
end get_compatible_predictable;

function get_compatible_predictable(myppredictable: String) return boolean is 
	mypredictable_predic : boolean := False;
begin
	if to_Unbounded_String(myppredictable) = to_Unbounded_String("True") 
	or to_Unbounded_String(myppredictable) = to_Unbounded_String("true") then
			mypredictable_predic := True;
	end if;
	if to_Unbounded_String(myppredictable) = to_Unbounded_String("False") or 
	to_Unbounded_String(myppredictable) = to_Unbounded_String("false") then
			mypredictable_predic := False;
	end if;
	if to_Unbounded_String(myppredictable) = to_Unbounded_String("") then
			mypredictable_predic := False;
	end if;
	return mypredictable_predic;
end get_compatible_predictable;

function get_compatible_policy(mypolicy: String) return Policies is 

mypolicy_pol : Policies;

begin
	if to_Unbounded_String(mypolicy) = to_Unbounded_String("Sched Fifo") then
			mypolicy_pol := Sched_Fifo;
	end if;

	if to_Unbounded_String(mypolicy) = to_Unbounded_String("Sched Rr") then
			mypolicy_pol := Sched_Rr;
	end if;

	if to_Unbounded_String(mypolicy) = to_Unbounded_String("Sched Others") then
			mypolicy_pol := Sched_Others;
	end if;

	return mypolicy_pol;

end get_compatible_policy;


procedure Deleted_In_Sys_Task(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class) is 
	A_Task      : Generic_Task_Ptr;
	name: unbounded_string;
begin
	name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));
	A_Task := Search_Task (Sys.Tasks, name);
	Delete_Task (Sys, A_Task);
end Deleted_In_Sys_Task;

procedure Show_In_Sys_Task(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class) is 
	A_Task      : Generic_Task_Ptr;
	name : unbounded_string;
	--offsets : Offsets_Table;
	tree_iter: Gtk_Tree_Iter;
	liststore: GObject; 
begin
	name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));
	A_Task := Search_task (Sys.tasks, name);

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

	for i in 0..A_Task.offsets.Nb_Entries -1
	loop
		Append(Gtk_List_Store(liststore), tree_iter);
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 0, gint(A_Task.offsets.Entries(i).activation));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, gint(A_Task.offsets.Entries(i).offset_value));
	end loop;
	
end Show_In_Sys_Task;

procedure Modify_In_Sys_Task(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class; name: unbounded_string) is 
	A_Task, A_Task_Buffer      : Generic_Task_Ptr;
begin
	A_Task := Search_Task (Sys.Tasks, name);
	A_Task_Buffer := A_Task;

	A_Task_Buffer.cheddar_private_id := A_Task.cheddar_private_id;
	A_Task_Buffer.name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));
	A_Task_Buffer.task_type := get_compatible_task(Get_Active_Text(Gtk_Combo_Box(my_tab(2).combo_value)));
	A_Task_Buffer.cpu_name := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(3).combo_value)));
	A_Task_Buffer.address_space_name := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(4).combo_value)));
	A_Task_Buffer.capacity := get_value_buffer_integer(Gtk_Text_Buffer(my_tab(5).buffer_value));
	A_Task_Buffer.deadline := get_value_buffer_integer(Gtk_Text_Buffer(my_tab(6).buffer_value));
	A_Task_Buffer.start_time := get_value_buffer_integer(Gtk_Text_Buffer(my_tab(7).buffer_value));
	A_Task_Buffer.priority := Priority_Range'value(to_string(get_value_buffer_string(Gtk_Text_Buffer(my_tab(8).buffer_value))));
	
	Periodic_Task_Ptr (A_Task_Buffer).period := get_value_buffer_integer(Gtk_Text_Buffer(my_tab(15).buffer_value));
	Periodic_Task_Ptr (A_Task_Buffer).jitter := get_value_buffer_integer(Gtk_Text_Buffer(my_tab(14).buffer_value));
	
	A_Task_buffer.blocking_time := get_value_buffer_integer(Gtk_Text_Buffer(my_tab(9).buffer_value));
	A_Task_Buffer.policy := get_compatible_policy(Get_Active_Text(Gtk_Combo_Box(my_tab(10).combo_value)));
	A_Task_Buffer.criticality := get_value_buffer_integer(Gtk_Text_Buffer(my_tab(13).buffer_value));

	Check_Task (sys.tasks, A_Task_Buffer.name, A_Task_Buffer.cpu_name, A_Task_Buffer.address_space_name, 
	A_Task_Buffer.task_type, A_Task_Buffer.start_time, A_Task_Buffer.capacity, Periodic_Task_Ptr (A_Task_Buffer).period, 
	A_Task_Buffer.deadline, Periodic_Task_Ptr (A_Task_Buffer).jitter, A_Task_buffer.blocking_time, 
	integer(A_Task_Buffer.priority), A_Task_Buffer.criticality , A_Task_Buffer.policy);
      --Offset                  : in Offsets_Table                 := No_Offset;
      --Stack_Memory_Size       : in Integer                       := 0;
      --Text_Memory_Size        : in Integer                       := 0;
      --Param                   : in User_Defined_Parameters_Table :=
     --No_User_Defined_Parameter;
     -- Parametric_Rule_Name    : in Unbounded_String              :=
     --empty_string;
      --Seed_Value              : in Integer                       := 0;
      --Predictable             : in Boolean                       := True;
      --context_switch_overhead : in Integer                       := 0);

	Delete_Task (Sys, A_Task);

	add (sys.tasks, a_task_buffer);

	--Add_Task (sys.tasks, task_name, Cpu_Name, Address_Space_Name, Task_Type, Start_Time , Capacity, Period, 
	--Deadline, Jitter, Blocking_Time, Priority_task, Criticality , Policy);
      --Offset                  : in Offsets_Table                 := No_Offset;
      --Stack_Memory_Size       : in Integer                       := 0;
      --Text_Memory_Size        : in Integer                       := 0;
      --Param                   : in User_Defined_Parameters_Table :=
     --No_User_Defined_Parameter;
     -- Parametric_Rule_Name    : in Unbounded_String              :=
     --empty_string;
      --Seed_Value              : in Integer                       := 0;
      --Predictable             : in Boolean                       := True;
      --context_switch_overhead : in Integer                       := 0);

	  exception
      when Task_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_Task;


function get_compatible_task(mytasktype: Gvalue) return Tasks_Type is 
	mytasktype_task: Tasks_type;
begin
	if to_Unbounded_String(Get_String(mytasktype)) = to_Unbounded_String("Periodic") then
		mytasktype_task := Periodic_Type;
	end if;

	if to_Unbounded_String(Get_String(mytasktype)) = to_Unbounded_String("Aperiodic") then
		mytasktype_task := Aperiodic_Type;
	end if;

	if to_Unbounded_String(Get_String(mytasktype)) = to_Unbounded_String("Sporadic") then
		mytasktype_task := Sporadic_Type;
	end if;

	if to_Unbounded_String(Get_String(mytasktype)) = to_Unbounded_String("Poisson") then
		mytasktype_task := Poisson_Type;
	end if;

	--if to_Unbounded_String(Get_String(mytasktype)) = to_Unbounded_String("Parametric") then
	if to_Unbounded_String(Get_String(mytasktype)) = to_Unbounded_String("User-defined") then
		mytasktype_task := Parametric_Type;
	end if;

	if to_Unbounded_String(Get_String(mytasktype)) = to_Unbounded_String("Scheduling Task") then
		mytasktype_task := Scheduling_Task_Type;
	end if;

	if to_Unbounded_String(Get_String(mytasktype)) = to_Unbounded_String("Frame Task") then
	--if to_Unbounded_String(Get_String(mytasktype)) = to_Unbounded_String("User-defined") then
		mytasktype_task := Frame_Task_Type;
	end if;

	return mytasktype_task;
end get_compatible_task;

function get_compatible_task(mytask: tasks_type) return unbounded_string is 
	mytask_string: unbounded_string;
begin
	--myscheduler_string:=to_Unbounded_String(schedulers_type'image(myscheduler));

	if mytask = Periodic_Type then 
			mytask_string:= to_Unbounded_String("Periodic");
	end if;

	if mytask = Aperiodic_Type then 
			mytask_string:= to_Unbounded_String("Aperiodic");
	end if;

	if mytask = Sporadic_Type then 
			mytask_string:= to_Unbounded_String("Sporadic");
	end if;

	if mytask = Poisson_Type then 
			mytask_string:= to_Unbounded_String("Poisson");
	end if;

	if mytask = Parametric_Type then 
			mytask_string:= to_Unbounded_String("User-defined");
	end if;

	if mytask = Scheduling_Task_Type then 
			mytask_string:= to_Unbounded_String("Scheduling Task");
	end if;

	if mytask = Frame_Task_Type then 
			mytask_string:= to_Unbounded_String("Frame Task");
	end if;

	return mytask_string;

end get_compatible_task;

function get_compatible_task(mytask: String) return tasks_Type is 

mytask_task : tasks_Type;

begin
	if to_Unbounded_String(mytask) = to_Unbounded_String("Periodic") then
			mytask_task := Periodic_Type;
	end if;

	if to_Unbounded_String(mytask) = to_Unbounded_String("Aperiodic") then
			mytask_task := Aperiodic_Type;
	end if;

	if to_Unbounded_String(mytask) = to_Unbounded_String("Sporadic") then
			mytask_task := Sporadic_Type;
	end if;

	if to_Unbounded_String(mytask) = to_Unbounded_String("Poisson") then
			mytask_task := Poisson_Type;
	end if;

	if to_Unbounded_String(mytask) = to_Unbounded_String("User-defined") then
			mytask_task := Parametric_Type;
	end if;

	if to_Unbounded_String(mytask) = to_Unbounded_String("Scheduling Task") then
			mytask_task := Scheduling_Task_Type;
	end if;

	if to_Unbounded_String(mytask) = to_Unbounded_String("Frame Task") then
			mytask_task := Frame_Task_Type;
	end if;

	return mytask_task;

end get_compatible_task;

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 Task_callbacks is new generic_callbacks(Number_of_widget => Task_table_length, Initialize => initialize_Task, 
	Check => Check_Task, Add_In_Sys => Add_In_Sys_Task, Deleted_In_Sys => Deleted_In_Sys_Task, 
	Modify_In_Sys => Modify_In_Sys_Task, Show_In_Sys => Show_In_Sys_Task);  use Task_callbacks;

procedure Show_Tasks_Widget is
 
	Builder : Gtkada_Builder;
	Error   : Glib.Error.GError;
	My_Iterator : Tasks_Iterator;
	A_Task: Generic_Task_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;

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

	Sys_buffer := sys;

	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_Text (Gtk_Text_Buffer(Get_Object(Builder, "textbuffer12")), "1");
	Set_Active (Gtk_Combo_Box(Get_Object(Builder, "combobox5")), 0);
	Set_Active (Gtk_Combo_Box(Get_Object(Builder, "combobox7")), 0);

	liststore:= Get_Object(Builder, "liststore4");
	reset_iterator (sys.Tasks, My_Iterator);
	if not is_empty (sys.Tasks) then
		loop
		current_element (sys.Tasks, A_Task, My_Iterator);
		Append(Gtk_List_Store(liststore), tree_iter);
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 0, To_String (A_Task.name));
		--Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, Tasks_Type'image(A_Task.task_type));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 2, To_String (A_Task.cpu_name));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 3, To_String (A_Task.address_space_name));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 4, Gint(A_Task.capacity));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 5, Gint(A_Task.deadline));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 6, Gint(A_Task.start_time));
		--Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 7, (A_Task.priority));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 7, Gint(A_Task.priority));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 8, Gint(A_Task.blocking_time));

		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 9, to_string(get_compatible_policy(A_Task.policy)));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 10, Gint(A_Task.text_memory_size));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 11, Gint(A_Task.stack_memory_size));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 12, Gint(A_Task.criticality));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 18, Gint(A_Task.context_switch_overhead));
		case A_Task.task_type is
		when Aperiodic_Type =>
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 13, Gint(0));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 14, Gint(0));
                	Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 15, "");
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, "Aperiodic");

		when Periodic_Type =>
	        	Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 13, Gint (Periodic_Task_Ptr (A_Task).jitter));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 14, Gint (Periodic_Task_Ptr (A_Task).period));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 15, "");
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, "Periodic");

		when Poisson_Type | Scheduling_Task_type  =>
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 13, Gint (Poisson_Task_Ptr (A_Task).jitter));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 14, Gint (Poisson_Task_Ptr (A_Task).period));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 15, "");
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, "Poisson");
			--Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 16, boolean'image(Poisson_Task_Ptr (A_Task).predictable));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 16, to_string(get_compatible_predictable(Poisson_Task_Ptr (A_Task).predictable)));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 17, Gint(Poisson_Task_Ptr (A_Task).seed));

		when Sporadic_Type =>
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 13, Gint (Sporadic_Task_Ptr (A_Task).jitter));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 14, Gint (Sporadic_Task_Ptr (A_Task).period));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 15, "");
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, "Sporadic");
                 
		when Parametric_Type =>
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 13, Gint (Poisson_Task_Ptr (A_Task).jitter));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 14, Gint (Poisson_Task_Ptr (A_Task).period));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 15, 
			To_String(Parametric_Task_Ptr (A_Task).activation_rule));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, "User-defined");

		when frame_task_type =>
			--cas a revoir après discussion avec frank et shuai ...
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 13, Gint (Poisson_Task_Ptr (A_Task).jitter));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 14, Gint (Poisson_Task_Ptr (A_Task).period));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 15, 
			To_String(Parametric_Task_Ptr (A_Task).activation_rule));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, "User-defined");

            end case;

	exit when is_last_element (sys.Tasks, My_Iterator);
	next_element (sys.Tasks, My_Iterator);
	         end loop;
      end if;

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

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

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

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

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

	Gtkada.Builder.Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button1_clicked", 
	Handler      => Task_callbacks.Close_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_Tasks_Widget;

end graphical_editor.tasks;