with Gtk;            use Gtk;
with Gtk.Main;       use Gtk.Main;
with Glib.Error;     use Glib.Error;
with Ada.Text_IO;
with graphical_editor.user_message;    use graphical_editor.user_message;
with Glib;      use Glib;
with Glib.Object; use Glib.Object;
with Translate;                      use Translate;
with Tasks;                             use Tasks;
with Task_Set;                          use Task_Set;
use Task_Set.Generic_Task_Set;
with Framework_Config;               use Framework_Config;
with Gtk.Combo_Box; 		use Gtk.Combo_Box;
with Buffers;                           use Buffers;
with Buffer_Set;                        use Buffer_Set;
use Buffer_Set.Generic_Buffer_Set;
with Messages; use Messages;
with Message_set; use Message_set;
with Resources; use Resources;
with Resource_set; use Resource_set;

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with unbounded_strings;     use unbounded_strings;

with task_dependencies; use task_dependencies;
use Task_Dependencies.Half_Dep_Set;
with Dependency_Services; use Dependency_Services;
with Dependencies; use Dependencies;


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 generic_package_widget; use generic_package_widget; 

package body graphical_editor.dependencies is

function get_compatible_dependencies(mydependency: String) return dependency_Type is 

mydependency_dep : dependency_Type;

begin
	if to_Unbounded_String(mydependency) = to_Unbounded_String("Precedence Dependency") then
			mydependency_dep := Precedence_Dependency;
	end if;

	if to_Unbounded_String(mydependency) = to_Unbounded_String("Queuing Buffer Dependency") then
			mydependency_dep := Queuing_Buffer_Dependency;
	end if;

	if to_Unbounded_String(mydependency) = to_Unbounded_String("Communication Dependency") then
			mydependency_dep := Communication_Dependency;
	end if;

	if to_Unbounded_String(mydependency) = to_Unbounded_String("Time Triggered Communication Dependency") then
			mydependency_dep := Time_Triggered_Communication_Dependency;
	end if;

	if to_Unbounded_String(mydependency) = to_Unbounded_String("Resource Dependency") then
			mydependency_dep := Resource_Dependency;
	end if;

	if to_Unbounded_String(mydependency) = to_Unbounded_String("Black Board Buffer Dependency") then
			mydependency_dep := Black_Board_Buffer_Dependency;
	end if;

	return mydependency_dep;

end get_compatible_dependencies;

function get_compatible_orientation(myorientation: String) return Orientation_Dependency_Type is 

myorientation_dep : Orientation_Dependency_Type;

begin
	if to_Unbounded_String(myorientation) = to_Unbounded_String("From Object To Task") then
			myorientation_dep := From_Object_To_Task;
	end if;

	if to_Unbounded_String(myorientation) = to_Unbounded_String("From Task To Object") then
			myorientation_dep := From_Task_To_Object;
	end if;

	return myorientation_dep;

end get_compatible_orientation;

function get_compatible_time_trigerred(mytrigerred: String) return Time_Triggered_Communication_Timing_Property_Type is 

mytrigerred_dep : Time_Triggered_Communication_Timing_Property_Type;

begin
	if to_Unbounded_String(mytrigerred) = to_Unbounded_String("Sampled Timing") then
			mytrigerred_dep := Sampled_Timing;
	end if;

	if to_Unbounded_String(mytrigerred) = to_Unbounded_String("Immediate Timing") then
			mytrigerred_dep := Immediate_Timing;
	end if;

	if to_Unbounded_String(mytrigerred) = to_Unbounded_String("Delayed Timing") then
			mytrigerred_dep := Delayed_Timing;
	end if;

	return mytrigerred_dep;

end get_compatible_time_trigerred;

function get_compatible_dependencies(mydependency: Gvalue) return dependency_type is 

begin
	return get_compatible_dependencies(Get_String(mydependency));

end get_compatible_dependencies;

function get_compatible_time_trigerred(mytrigerred: Gvalue) return Time_Triggered_Communication_Timing_Property_Type is 

begin
	return get_compatible_time_trigerred(Get_String(mytrigerred));

end get_compatible_time_trigerred;

function get_compatible_orientation(myorientation: Gvalue) return Orientation_Dependency_Type is 

begin
	return get_compatible_orientation(Get_String(myorientation));

end get_compatible_orientation;

function get_compatible_dependencies(mydependency: dependency_type) return unbounded_string is 
mydependency_string: unbounded_string;
begin

	if mydependency = Precedence_Dependency then 
			mydependency_string:= to_Unbounded_String("Precedence Dependency");
	end if;

	if mydependency = Queuing_Buffer_Dependency then 
			mydependency_string:= to_Unbounded_String("Queuing Buffer Dependency");
	end if;

	if mydependency = Communication_Dependency then 
			mydependency_string:= to_Unbounded_String("Communication Dependency");
	end if;

	if mydependency = Time_Triggered_Communication_Dependency then 
			mydependency_string:= to_Unbounded_String("Time Triggered Communication Dependency");
	end if;

	if mydependency = Resource_Dependency then 
			mydependency_string:= to_Unbounded_String("Resource Dependency");
	end if;

	if mydependency = Black_Board_Buffer_Dependency then 
			mydependency_string:= to_Unbounded_String("Black Board Buffer Dependency");
	end if;

	return mydependency_string;

end get_compatible_dependencies;

function get_compatible_orientation(myorientation: Orientation_Dependency_Type) return unbounded_string is 
myorientation_string: unbounded_string;
begin

	if myorientation = From_Object_To_Task then 
			myorientation_string:= to_Unbounded_String("From Object To Task");
	end if;

	if myorientation = From_Task_To_Object then 
			myorientation_string:= to_Unbounded_String("From Task To Object");
	end if;

	return myorientation_string;

end get_compatible_orientation;

function get_compatible_time_trigerred(mytrigerred: Time_Triggered_Communication_Timing_Property_Type) return unbounded_string is 
mytrigerred_string: unbounded_string;
begin

	if mytrigerred = Sampled_Timing then 
			mytrigerred_string:= to_Unbounded_String("Sampled Timing");
	end if;

	if mytrigerred = Immediate_Timing then 
			mytrigerred_string:= to_Unbounded_String("Immediate Timing");
	end if;

	if mytrigerred = Delayed_Timing then 
			mytrigerred_string:= to_Unbounded_String("Delayed Timing");
	end if;

	return mytrigerred_string;

end get_compatible_time_trigerred;

procedure add_view_communication (Object : access Gtkada_Builder_Record'Class) is 
	liststore : GObject;
	tree_iter: Gtk_Tree_Iter;
	communication_dependency_task, communication_orientation, communication_dependency_object : Unbounded_String;

begin
	liststore:= Get_Object(Object, "liststore11");
	Gtk.List_Store.Clear(Gtk_List_Store(liststore));
	communication_dependency_task := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox7"))));
	if (communication_dependency_task = "") then
		Show_Message_Box (Lb_Select_communication_dependency_task_Before (Current_Language));
		return;
        end if;
	communication_orientation := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox8"))));
	if (communication_orientation = "") then
		Show_Message_Box (Lb_Select_communication_orientation_Before (Current_Language));
		return;
        end if;
	communication_dependency_object := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox9"))));
	if (communication_dependency_object = "") then
		Show_Message_Box (Lb_Select_communication_dependency_object_Before (Current_Language));
		return;
        end if;
	Append(Gtk_List_Store(liststore), tree_iter);
	Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 0, 
	Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox7"))));
	Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, 
	Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox8"))));
	Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 2, 
	Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox9"))));

end add_view_communication;

procedure add_view_queuing (Object : access Gtkada_Builder_Record'Class) is 
	liststore : GObject;
	tree_iter: Gtk_Tree_Iter;
	buffer_dependency_task, buffer_orientation, buffer_dependency_object : Unbounded_String;
begin
	liststore:= Get_Object(Object, "liststore7");
	Gtk.List_Store.Clear(Gtk_List_Store(liststore));
	buffer_dependency_task := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox4"))));
	if (buffer_dependency_task = "") then
		Show_Message_Box (Lb_Select_buffer_dependency_task_Before (Current_Language));
		return;
        end if;
	buffer_orientation := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox5"))));
	if (buffer_orientation = "") then
		Show_Message_Box (Lb_Select_Buffer_Orientation_Before (Current_Language));
		return;
        end if;
	buffer_dependency_object := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox6"))));
	if (buffer_dependency_object = "") then
		Show_Message_Box (Lb_Select_Buffer_Dependency_Object_Before (Current_Language));
		return;
        end if;
	Append(Gtk_List_Store(liststore), tree_iter);
	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, 
	Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox5"))));
	Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 2, 
	Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox6"))));

end add_view_queuing;

procedure add_view_time (Object : access Gtkada_Builder_Record'Class) is 

	liststore : GObject;
	time_triggered_communication_sink, time_triggered_communication_source, timing_property : Unbounded_String;
	tree_iter: Gtk_Tree_Iter;

begin
	liststore:= Get_Object(Object, "liststore15");
	Gtk.List_Store.Clear(Gtk_List_Store(liststore));
	time_triggered_communication_sink := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox10"))));
	if (time_triggered_communication_sink = "") then
		Show_Message_Box (Lb_Select_time_triggered_communication_sink_Before (Current_Language));
		return;
        end if;
	time_triggered_communication_source := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox11"))));
	if (time_triggered_communication_source = "") then
		Show_Message_Box (Lb_Select_time_triggered_communication_source_Before (Current_Language));
		return;
        end if;
	timing_property := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox12"))));
	if (timing_property = "") then
		Show_Message_Box (Lb_Select_timing_property_Before (Current_Language));
		return;
        end if;
	Append(Gtk_List_Store(liststore), tree_iter);
	Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 0, 
	Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox10"))));
	Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, 
	Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox11"))));
	Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 2, 
	Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox12"))));

end add_view_time;

procedure add_view_resource (Object : access Gtkada_Builder_Record'Class) is 

	liststore : GObject;
	resource_dependency_resource, resource_dependency_task : Unbounded_String;
	tree_iter: Gtk_Tree_Iter;

begin
	liststore:= Get_Object(Object, "liststore18");
	Gtk.List_Store.Clear(Gtk_List_Store(liststore));
	resource_dependency_resource := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox13"))));
	if (resource_dependency_resource = "") then
		Show_Message_Box (Lb_Select_resource_dependency_resource_Before (Current_Language));
		return;
        end if;
	resource_dependency_task := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox14"))));
	if (resource_dependency_task = "") then
		Show_Message_Box (Lb_Select_resource_dependency_task_Before (Current_Language));
		return;
        end if;
	Append(Gtk_List_Store(liststore), tree_iter);
	Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 0, 
	Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox13"))));
	Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, 
	Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox14"))));

end add_view_resource;

procedure add_view_black (Object : access Gtkada_Builder_Record'Class) is 

	liststore : GObject;
	black_board_dependent_task, black_board_orientation, black_board_dependency_object : Unbounded_String;
	tree_iter: Gtk_Tree_Iter;

begin

	liststore:= Get_Object(Object, "liststore22");
	Gtk.List_Store.Clear(Gtk_List_Store(liststore));
	black_board_dependent_task := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox15"))));
	if (black_board_dependent_task = "") then
		Show_Message_Box (Lb_Select_black_board_dependent_task_Before (Current_Language));
		return;
        end if;
	black_board_orientation := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox16"))));
	if (black_board_orientation = "") then
		Show_Message_Box (Lb_Select_black_board_orientation_Before (Current_Language));
		return;
        end if;
	black_board_dependency_object := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox17"))));
	if (black_board_dependency_object = "") then
		Show_Message_Box (Lb_Select_black_board_dependency_object_Before (Current_Language));
		return;
        end if;
	Append(Gtk_List_Store(liststore), tree_iter);
	Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 0, 
	Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox15"))));
	Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, 
	Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox16"))));
	Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 2, 
	Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox17"))));

end add_view_black;

procedure add_view_precedence (Object : access Gtkada_Builder_Record'Class) is 

	liststore : GObject;
	precedence_sink, precedence_source : Unbounded_String;
	tree_iter: Gtk_Tree_Iter;

begin
	liststore:= Get_Object(Object, "liststore3");
	Gtk.List_Store.Clear(Gtk_List_Store(liststore));
	precedence_sink := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox2"))));
	if (precedence_sink = "") then
		Show_Message_Box (Lb_Select_Precedence_Sink_Before (Current_Language));
		return;
        end if;
	precedence_source := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox3"))));
	if (precedence_source = "") then
		Show_Message_Box (Lb_Select_Precedence_Source_Before (Current_Language));
		return;
        end if;
	Append(Gtk_List_Store(liststore), tree_iter);
	Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 0, 
	Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox2"))));
	Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, 
	Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox3"))));

end add_view_precedence;

procedure delete_dependencies (Object : access Gtkada_Builder_Record'Class) is 

	tree_iter, tree_iter_pd, tree_iter_qbd, tree_iter_cd, tree_iter_ttd, tree_iter_rd, tree_iter_bbd: Gtk_Tree_Iter;
	path1: Gtk_Tree_Path;
	focus1: Gtk_Tree_View_Column;
	a_dependency_type, precedence_sink, precedence_source, buffer_dependency_task, buffer_orientation, 
	buffer_dependency_object, communication_dependency_task, communication_orientation, 
	communication_dependency_object, time_triggered_communication_sink, time_triggered_communication_source, 
	timing_property, resource_dependency_resource, resource_dependency_task, black_board_dependency_task, 
	black_board_orientation, black_board_dependency_object : 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, "liststore1")), path1);
		a_dependency_type := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), 
		tree_iter, 0));

		if a_dependency_type = to_unbounded_string("Precedence Dependency") then 
			precedence_sink := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, 
			"liststore1")), tree_iter, 1));
			precedence_source := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, 
			"liststore1")), tree_iter, 3));
			Delete_One_Task_Dependency (sys.Dependencies, Search_Task(sys.tasks, precedence_sink), 
			Search_Task(sys.tasks, precedence_source));
			Gtk.List_Store.Remove(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter);
			tree_iter_pd := Get_Iter_First (Gtk_Tree_Model(Gtk.Tree_View.Get_Model(Gtk_Tree_view(Get_Object(Object, 
			"treeview2")))));
			Gtk.List_Store.Remove(Gtk_List_Store(Get_Object(Object, "liststore3")), tree_iter_pd);
			Set_Active(Gtk_Combo_Box(Get_Object(Object, "combobox1")), Gint(-1));
		end if;

		if a_dependency_type = to_unbounded_string("Queuing Buffer Dependency") then 
			buffer_dependency_task := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, 
			"liststore1")), tree_iter, 1));
			buffer_orientation := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, 
			"liststore1")), tree_iter, 2));
			buffer_dependency_object := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, 
			"liststore1")), tree_iter, 3));
			Delete_One_Task_Dependency(sys.Dependencies, Search_Task(sys.tasks, buffer_dependency_task), 
			Search_Buffer(sys.buffers, buffer_dependency_object), get_compatible_orientation(to_string(buffer_orientation)));
			Gtk.List_Store.Remove(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter);
			tree_iter_qbd := Get_Iter_First (Gtk_Tree_Model(Gtk.Tree_View.Get_Model(Gtk_Tree_view(Get_Object(Object, 
			"treeview3")))));
			Gtk.List_Store.Remove(Gtk_List_Store(Get_Object(Object, "liststore7")), tree_iter_qbd);
			Set_Active(Gtk_Combo_Box(Get_Object(Object, "combobox1")), Gint(-1));
		end if;

		if a_dependency_type = to_unbounded_string("Communication Dependency") then 
			communication_dependency_task := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, 
			"liststore1")), tree_iter, 1));
			communication_orientation := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, 
			"liststore1")), tree_iter, 2));
			communication_dependency_object := 
			to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, 
			"liststore1")), tree_iter, 3));
			Delete_One_Task_Dependency(sys.Dependencies, Search_Task(sys.tasks, communication_dependency_task), 
			Search_Message(sys.messages, communication_dependency_object), 
			get_compatible_orientation(to_string(communication_orientation)));
			Gtk.List_Store.Remove(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter);
			tree_iter_cd := Get_Iter_First (Gtk_Tree_Model(Gtk.Tree_View.Get_Model(Gtk_Tree_view(Get_Object(Object, 
			"treeview4")))));
			Gtk.List_Store.Remove(Gtk_List_Store(Get_Object(Object, "liststore11")), tree_iter_cd);
			Set_Active(Gtk_Combo_Box(Get_Object(Object, "combobox1")), Gint(-1));
		end if;

		if a_dependency_type = to_unbounded_string("Time Triggered Communication Dependency") then 
			time_triggered_communication_sink := 
			to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), tree_iter, 1));
			time_triggered_communication_source := 
			to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), tree_iter, 3));
			timing_property := 
			to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), tree_iter, 2));
			Delete_One_Task_Dependency(sys.Dependencies, Search_Task(sys.tasks, time_triggered_communication_sink), 
			Search_Task(sys.tasks, time_triggered_communication_source)); 
			--get_compatible_time_trigerred(to_string(timing_property)));
			Gtk.List_Store.Remove(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter);
			tree_iter_ttd := Get_Iter_First (Gtk_Tree_Model(Gtk.Tree_View.Get_Model(Gtk_Tree_view(Get_Object(Object, 
			"treeview5")))));
			Gtk.List_Store.Remove(Gtk_List_Store(Get_Object(Object, "liststore15")), tree_iter_ttd);
			Set_Active(Gtk_Combo_Box(Get_Object(Object, "combobox1")), Gint(-1));
		end if;

		if a_dependency_type = to_unbounded_string("Resource Dependency") then 
			resource_dependency_resource := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, 
			"liststore1")), tree_iter, 1));
			resource_dependency_task := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, 
			"liststore1")), tree_iter, 3));
			Gtk.List_Store.Remove(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter);
			Delete_One_Task_Dependency(sys.Dependencies, Search_Task(sys.tasks, resource_dependency_task), 
			Search_Resource(sys.resources, resource_dependency_resource));
			tree_iter_rd := Get_Iter_First (Gtk_Tree_Model(Gtk.Tree_View.Get_Model(Gtk_Tree_view(Get_Object(Object, 
			"treeview6")))));
			Gtk.List_Store.Remove(Gtk_List_Store(Get_Object(Object, "liststore18")), tree_iter_rd);
			Set_Active(Gtk_Combo_Box(Get_Object(Object, "combobox1")), Gint(-1));
		end if;

		if a_dependency_type = to_unbounded_string("Black Board Buffer Dependency") then 
			black_board_dependency_task := 
			to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), tree_iter, 1));
			black_board_orientation := 
			to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), tree_iter, 2));
			black_board_dependency_object := 
			to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), tree_iter, 3));
			Delete_One_Task_Dependency(sys.Dependencies, Search_Task(sys.tasks, black_board_dependency_task), 
			Search_Buffer(sys.buffers, black_board_dependency_object), 
			get_compatible_orientation(to_string(black_board_orientation)));
			tree_iter_bbd := Get_Iter_First (Gtk_Tree_Model(Gtk.Tree_View.Get_Model(Gtk_Tree_view(Get_Object(Object, 
			"treeview7")))));
			Gtk.List_Store.Remove(Gtk_List_Store(Get_Object(Object, "liststore22")), tree_iter_bbd);
			Set_Active(Gtk_Combo_Box(Get_Object(Object, "combobox1")), Gint(-1));
		end if;
	else 
		Show_Message_Box (Lb_Select_Line_Before (Current_Language));
	end if;
end delete_dependencies;

procedure add_dependencies (Object : access Gtkada_Builder_Record'Class) is 

	a_dependency_type, precedence_sink, precedence_source, buffer_dependency_task, buffer_orientation, 
	buffer_dependency_object, communication_dependency_task, communication_orientation, 
	communication_dependency_object, time_triggered_communication_sink, time_triggered_communication_source, 
	timing_property, resource_dependency_resource, resource_dependency_task, black_board_dependency_task, 
	black_board_orientation, black_board_dependency_object : unbounded_string;
	tree_iter, tree_iter_pd, tree_iter_qbd, tree_iter_cd, tree_iter_ttd, tree_iter_rd, tree_iter_bbd : Gtk_Tree_Iter;
	liststore : GObject;
	number_rows : integer;

begin

	a_dependency_type := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(Get_Object(Object, "combobox1"))));
	if (a_dependency_type = "") then
		Show_Message_Box (Lb_Select_dependency_type_Before (Current_Language));
		return;
        end if;

	if a_dependency_type = to_unbounded_string("Precedence Dependency") then 
		liststore:= Get_Object(Object, "liststore3");
		number_rows:= 
		get_number_elements(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(Gtk_Tree_view(Get_Object(Object, "treeview2")))));
		if number_rows = 0 then 
			Show_Message_Box (Lb_Add_Precedence_Dependency_Before (Current_Language));
			return;
		end if;
		tree_iter_pd := Get_Iter_First (Gtk_Tree_Model(Gtk.Tree_View.Get_Model(Gtk_Tree_view(Get_Object(Object, "treeview2")))));
		precedence_sink := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(liststore), 
		tree_iter_pd, 0));
		precedence_source := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(liststore), 
		tree_iter_pd, 1));

		Add_One_Task_Dependency(sys.Dependencies, Search_Task(sys.tasks, precedence_sink), 
		Search_Task(sys.tasks, precedence_source));

		Append(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter);		
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 0, "Precedence Dependency");
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 1, to_string(precedence_sink));
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 3, to_string(precedence_source));
	end if;

	if a_dependency_type = to_unbounded_string("Queuing Buffer Dependency") then 
		liststore:= Get_Object(Object, "liststore7");
		number_rows:= 
		get_number_elements(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(Gtk_Tree_view(Get_Object(Object, "treeview3")))));
		if number_rows = 0 then 
			Show_Message_Box (Lb_Add_Queuing_Buffer_Dependency_Before (Current_Language));
			return;
		end if;
		tree_iter_qbd := Get_Iter_First (Gtk_Tree_Model(Gtk.Tree_View.Get_Model(Gtk_Tree_view(Get_Object(Object, 
		"treeview3")))));
		buffer_dependency_task := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(liststore), 
		tree_iter_qbd, 0));
		buffer_orientation := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(liststore), 
		tree_iter_qbd, 1));
		buffer_dependency_object := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(liststore), 
		tree_iter_qbd, 2));


		Add_One_Task_Dependency(sys.Dependencies, Search_Task(sys.tasks, buffer_dependency_task), 
		Search_Buffer(sys.buffers, buffer_dependency_object), get_compatible_orientation(to_string(buffer_orientation)));

		Append(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter);		
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 0, "Queuing Buffer Dependency");
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 1, to_string(buffer_dependency_task));
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 2, to_string(buffer_orientation));
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 3, to_string(buffer_dependency_object));
	end if;

	if a_dependency_type = to_unbounded_string("Communication Dependency") then 
		liststore:= Get_Object(Object, "liststore11");
		number_rows:= 
		get_number_elements(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(Gtk_Tree_view(Get_Object(Object, "treeview4")))));
		if number_rows = 0 then 
			Show_Message_Box (Lb_Add_Communication_Dependency_Before (Current_Language));
			return;
		end if;
		tree_iter_cd := Get_Iter_First (Gtk_Tree_Model(Gtk.Tree_View.Get_Model(Gtk_Tree_view(Get_Object(Object, "treeview4")))));
		communication_dependency_task := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(liststore), 
		tree_iter_cd, 0));
		communication_orientation := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(liststore), 
		tree_iter_cd, 1));
		communication_dependency_object := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(liststore), 
		tree_iter_cd, 2));


		Add_One_Task_Dependency(sys.Dependencies, Search_Task(sys.tasks, communication_dependency_task), 
		Search_Message(sys.messages, communication_dependency_object), 
		get_compatible_orientation(to_string(communication_orientation)));

		Append(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter);		
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 0, "Communication Dependency");
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 1, 
		to_string(communication_dependency_task));
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 2, to_string(communication_orientation));
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 3, 
		to_string(communication_dependency_object));
	end if;

	if a_dependency_type = to_unbounded_string("Time Triggered Communication Dependency") then 
		liststore:= Get_Object(Object, "liststore15");
		number_rows:= 
		get_number_elements(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(Gtk_Tree_view(Get_Object(Object, "treeview5")))));
		if number_rows = 0 then 
			Show_Message_Box (Lb_Add_Time_Triggered_Dependency_Before (Current_Language));
			return;
		end if;
		tree_iter_ttd := Get_Iter_First (Gtk_Tree_Model(Gtk.Tree_View.Get_Model(Gtk_Tree_view(Get_Object(Object, 
		"treeview5")))));
		time_triggered_communication_sink := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(liststore), 
		tree_iter_ttd, 0));
		time_triggered_communication_source := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(liststore), 
		tree_iter_ttd, 1));
		timing_property := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(liststore), 
		tree_iter_ttd, 2));


		Add_One_Task_Dependency(sys.Dependencies, Search_Task(sys.tasks, time_triggered_communication_sink), 
		Search_Task(sys.tasks, time_triggered_communication_source), 
		get_compatible_time_trigerred(to_string(timing_property)));

		Append(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter);		
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 0, "Time Triggered Dependency");
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 1, 
		to_string(time_triggered_communication_sink));
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 2, to_string(timing_property));
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 3, 
		to_string(time_triggered_communication_source));
	end if;

	if a_dependency_type = to_unbounded_string("Resource Dependency") then 
		liststore:= Get_Object(Object, "liststore18");
		number_rows:= 
		get_number_elements(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(Gtk_Tree_view(Get_Object(Object, "treeview6")))));
		if number_rows = 0 then 
			Show_Message_Box (Lb_Add_Resource_Dependency_Before (Current_Language));
			return;
		end if;
		tree_iter_rd := Get_Iter_First (Gtk_Tree_Model(Gtk.Tree_View.Get_Model(Gtk_Tree_view(Get_Object(Object, "treeview6")))));
		resource_dependency_resource := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(liststore), 
		tree_iter_rd, 0));
		resource_dependency_task := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(liststore), 
		tree_iter_rd, 1));

		Add_One_Task_Dependency(sys.Dependencies, Search_Task(sys.tasks, resource_dependency_task), 
		Search_Resource(sys.resources, resource_dependency_resource));

		Append(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter);		
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 0, "Resource Dependency");
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 1, 
		to_string(resource_dependency_resource));
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 3, to_string(resource_dependency_task));
	end if;

	if a_dependency_type = to_unbounded_string("Black Board Buffer Dependency") then 
		liststore:= Get_Object(Object, "liststore22");
		number_rows:= 
		get_number_elements(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(Gtk_Tree_view(Get_Object(Object, "treeview7")))));
		if number_rows = 0 then 
			Show_Message_Box (Lb_Add_Black_Board_Buffer_Dependency_Before (Current_Language));
			return;
		end if;
		tree_iter_bbd := Get_Iter_First (Gtk_Tree_Model(Gtk.Tree_View.Get_Model(Gtk_Tree_view(Get_Object(Object, 
		"treeview7")))));
		black_board_dependency_task := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(liststore), 
		tree_iter_bbd, 0));
		black_board_orientation := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(liststore), 
		tree_iter_bbd, 1));
		black_board_dependency_object := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(liststore), 
		tree_iter_bbd, 2));


		Add_One_Task_Dependency(sys.Dependencies, Search_Task(sys.tasks, black_board_dependency_task), 
		Search_Buffer(sys.buffers, black_board_dependency_object), 
		get_compatible_orientation(to_string(black_board_orientation)));

		Append(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter);		
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 0, "Black Board Buffer Dependency");
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 1, 
		to_string(black_board_dependency_task));
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 2, to_string(black_board_orientation));
		Gtk.List_Store.Set(Gtk_List_Store(Get_Object(Object, "liststore1")), tree_iter, 3, 
		to_string(black_board_dependency_object));
	end if;

end add_dependencies;

procedure show_lign_precedence_selected (Object : access Gtkada_Builder_Record'Class) is 
	tree_iter : Gtk_Tree_Iter;
	path1: Gtk_Tree_Path;
	focus1: Gtk_Tree_View_Column;
	precedence_sink, precedence_source: 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, "liststore3")), path1);
	precedence_sink := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore3")), 
	tree_iter, 0));
	precedence_source := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore3")), 
	tree_iter, 1));
	Set_Active(Gtk_Combo_Box(Get_Object(Object, "combobox2")), 
	Gint(get_int_combo(Gtk_Combo_Box(Get_Object(Object, "combobox2")), precedence_sink)));
	Set_Active(Gtk_Combo_Box(Get_Object(Object, "combobox3")), 
	Gint(get_int_combo(Gtk_Combo_Box(Get_Object(Object, "combobox3")), precedence_source)));
	end if;
end show_lign_precedence_selected;

procedure close_widget (Object : access Gtkada_Builder_Record'Class) is

	my_widget : GObject;

begin
	Is_New   := False;
	Is_Saved := False;
	my_widget:=Get_Object(Object, "window1");
	Destroy_cb(Gtk_Widget(my_widget));
	gtk.main.main_quit;
end close_widget;

procedure cancel_widget  (Object : access Gtkada_Builder_Record'Class) is 

	my_widget : GObject;

begin

	my_widget:=Get_Object(Object, "window1");
	duplicate(sys_buffer, sys);

	Destroy_cb(Gtk_Widget(my_widget));
	gtk.main.main_quit;
end cancel_widget;

procedure Show_Lign_Selected (Object : access Gtkada_Builder_Record'Class) is 

	tree_iter, tree_iter_pd, tree_iter_qbd, tree_iter_cd, tree_iter_ttd, tree_iter_rd, tree_iter_bbd: Gtk_Tree_Iter;
	path1: Gtk_Tree_Path;
	focus1: Gtk_Tree_View_Column;
	combo_text, A_text: unbounded_string;
	liststore_pd, liststore_qbd, liststore_cd, liststore_ttd, liststore_rd, liststore_bbd: GObject;

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, "liststore1")), path1);

	combo_text := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), 
	tree_iter, 0));
	Set_Active(Gtk_Combo_Box(Get_Object(Object, "combobox1")), 
	Gint(get_int_combo(Gtk_Combo_Box(Get_Object(Object, "combobox1")), combo_text)));

	liststore_pd:= Get_Object(Object, "liststore3");
	Gtk.List_Store.Clear(Gtk_List_Store(liststore_pd));
	liststore_qbd:= Get_Object(Object, "liststore7");
	Gtk.List_Store.Clear(Gtk_List_Store(liststore_qbd));
	liststore_cd:= Get_Object(Object, "liststore11");
	Gtk.List_Store.Clear(Gtk_List_Store(liststore_cd));
	liststore_ttd:= Get_Object(Object, "liststore11");
	Gtk.List_Store.Clear(Gtk_List_Store(liststore_ttd));
	liststore_rd:= Get_Object(Object, "liststore18");
	Gtk.List_Store.Clear(Gtk_List_Store(liststore_rd));
	liststore_bbd:= Get_Object(Object, "liststore22");
	Gtk.List_Store.Clear(Gtk_List_Store(liststore_bbd));

	if combo_text = to_unbounded_string("Precedence Dependency") then 
		Append(Gtk_List_Store(liststore_pd), tree_iter_pd);
		A_text := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), 
		tree_iter, 1));
		Gtk.List_Store.Set(Gtk_List_Store(liststore_pd), tree_iter_pd, 0, To_String (A_text));
		A_text := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), 
		tree_iter, 3));
		Gtk.List_Store.Set(Gtk_List_Store(liststore_pd), tree_iter_pd, 1, To_String (A_text));
	end if;

	if combo_text = to_unbounded_string("Queuing Buffer Dependency") then 
		Append(Gtk_List_Store(liststore_qbd), tree_iter_qbd);
		A_text := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), 
		tree_iter, 1));
		Gtk.List_Store.Set(Gtk_List_Store(liststore_qbd), tree_iter_qbd, 0, To_String (A_text));
		A_text := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), 
		tree_iter, 2));
		Gtk.List_Store.Set(Gtk_List_Store(liststore_qbd), tree_iter_qbd, 1, To_String (A_text));
		A_text := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), 
		tree_iter, 3));
		Gtk.List_Store.Set(Gtk_List_Store(liststore_qbd), tree_iter_qbd, 2, To_String (A_text));
	end if;

	if combo_text = to_unbounded_string("Communication Dependency") then 
		Append(Gtk_List_Store(liststore_cd), tree_iter_cd);
		A_text := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), 
		tree_iter, 1));
		Gtk.List_Store.Set(Gtk_List_Store(liststore_cd), tree_iter_cd, 0, To_String (A_text));
		A_text := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), 
		tree_iter, 2));
		Gtk.List_Store.Set(Gtk_List_Store(liststore_cd), tree_iter_cd, 1, To_String (A_text));
		A_text := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), 
		tree_iter, 3));
		Gtk.List_Store.Set(Gtk_List_Store(liststore_cd), tree_iter_cd, 2, To_String (A_text));
	end if;

	if combo_text = to_unbounded_string("Time Triggered Communication Dependency") then 
		Append(Gtk_List_Store(liststore_ttd), tree_iter_ttd);
		A_text := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), 
		tree_iter, 1));
		Gtk.List_Store.Set(Gtk_List_Store(liststore_ttd), tree_iter_ttd, 0, To_String (A_text));
		A_text := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), 
		tree_iter, 2));
		Gtk.List_Store.Set(Gtk_List_Store(liststore_ttd), tree_iter_ttd, 1, To_String (A_text));
		A_text := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), 
		tree_iter, 3));
		Gtk.List_Store.Set(Gtk_List_Store(liststore_ttd), tree_iter_ttd, 2, To_String (A_text));
	end if;

	if combo_text = to_unbounded_string("Resource Dependency") then 
		Append(Gtk_List_Store(liststore_rd), tree_iter_rd);
		A_text := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), 
		tree_iter, 1));
		Gtk.List_Store.Set(Gtk_List_Store(liststore_rd), tree_iter_rd, 0, To_String (A_text));
		A_text := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), 
		tree_iter, 3));
		Gtk.List_Store.Set(Gtk_List_Store(liststore_rd), tree_iter_rd, 1, To_String (A_text));
	end if;

	if combo_text = to_unbounded_string("Black Board Buffer Dependency") then 
		Append(Gtk_List_Store(liststore_bbd), tree_iter_bbd);
		A_text := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), 
		tree_iter, 1));
		Gtk.List_Store.Set(Gtk_List_Store(liststore_bbd), tree_iter_bbd, 0, To_String (A_text));
		A_text := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), 
		tree_iter, 2));
		Gtk.List_Store.Set(Gtk_List_Store(liststore_bbd), tree_iter_bbd, 1, To_String (A_text));
		A_text := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore1")), 
		tree_iter, 3));
		Gtk.List_Store.Set(Gtk_List_Store(liststore_bbd), tree_iter_bbd, 2, To_String (A_text));
	end if;

	end if;

end Show_Lign_Selected;

procedure delete_view_precedence (Object : access Gtkada_Builder_Record'Class) is 

	tree_iter: Gtk_Tree_Iter;
	path1: Gtk_Tree_Path;
	focus1: Gtk_Tree_View_Column;
	precedence_sink, precedence_source: unbounded_string;
	task_sink, task_source: Generic_Task_Ptr;

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, "liststore3")), path1);
		precedence_sink := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore3")), 
		tree_iter, 0));
		precedence_source := to_unbounded_string(Gtk.Tree_Model.Get_String(Gtk_Tree_Model(Get_Object(Object, "liststore3")), 
		tree_iter, 1));
		task_sink := Search_Task(sys.tasks, precedence_sink);
		task_source := Search_Task(sys.tasks, precedence_source);
		--put_line(to_string(task_sink.name)); put_line(to_string(task_source.name));
		--Delete_One_Task_Dependency (sys.Dependencies, task_sink, task_source);
		Gtk.List_Store.Remove(Gtk_List_Store(Get_Object(Object, "liststore3")), tree_iter);
		Set_Active(Gtk_Combo_Box(Get_Object(Object, "combobox2")), Gint(-1));
		Set_Active(Gtk_Combo_Box(Get_Object(Object, "combobox3")), Gint(-1));
	else 
		Show_Message_Box (Lb_Select_Line_Before (Current_Language));
	end if;

end delete_view_precedence;

procedure show_dependencies_widget is

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

	My_Iterator : Tasks_Iterator;
	My_Iterator_dep : Tasks_Dependencies_Iterator;
	An_Dependency: Dependency_Ptr;

	tree_iter: Gtk_Tree_Iter;
	liststore: GObject;

	my_combo_task_sink, my_combo_task_source, my_combo_buffer_task, my_combo_queing_buffer, my_combo_communication_task, 
	my_combo_communication_message, my_combo_task_triggered_sink, my_combo_task_triggered_source, 
	my_combo_dependencies_resource, my_combo_task_resource, my_combo_bb_task, my_combo_bb_buffer: GObject;
	My_Task_Iterator : Tasks_Iterator;
	My_Buffer_Iterator : Buffers_Iterator;
	My_Message_Iterator : Messages_Iterator;
	My_Resource_Iterator : Resources_Iterator;
	A_Task : Generic_Task_Ptr;
	A_Buffer : Buffer_Ptr;
	A_Message : Generic_Message_Ptr;
	A_Resource : Generic_Resource_Ptr;

begin
	Gtk.Main.Init;
	Gtk_New (Builder);
	Error := Add_From_File (Builder, to_string(Glade_path) & "dependencies.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_task_sink := Get_Object(Builder, "combobox2");
	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_combo_task_sink), 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_task_source := Get_Object(Builder, "combobox3");
	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_combo_task_source), 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_buffer_task := 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_combo_buffer_task), 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_queing_buffer := Get_Object(Builder, "combobox6");
	reset_iterator (sys.Buffers, My_Buffer_Iterator);
	if not is_empty (sys.Buffers) then 
	loop
	current_element (sys.Buffers, A_Buffer, My_Buffer_Iterator);
	
	Append_Text (Gtk_Combo_Box(my_combo_queing_buffer), To_String(A_Buffer.name));
	exit when is_last_element (sys.Buffers, My_Buffer_Iterator);
		next_element (sys.Buffers, My_Buffer_Iterator);
	end loop;
	else
	Show_Message_Box (Lb_Define_Buffers_Before (Current_Language));
	end if;

	my_combo_communication_task := Get_Object(Builder, "combobox7");
	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_combo_communication_task), 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_communication_message := Get_Object(Builder, "combobox9");
	reset_iterator (sys.Messages, My_Message_Iterator);
	if not is_empty (sys.Messages) then 
	loop
	current_element (sys.Messages, A_Message, My_Message_Iterator);
	
	Append_Text (Gtk_Combo_Box(my_combo_communication_message), To_String(A_Message.name));
	exit when is_last_element (sys.Messages, My_Message_Iterator);
		next_element (sys.Messages, My_Message_Iterator);
	end loop;
	else
	Show_Message_Box (Lb_Define_Messages_Before (Current_Language));
	end if;

	my_combo_task_triggered_sink := Get_Object(Builder, "combobox10");
	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_combo_task_triggered_sink), 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_task_triggered_source := Get_Object(Builder, "combobox11");
	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_combo_task_triggered_source), 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_dependencies_resource := Get_Object(Builder, "combobox13");
	reset_iterator (sys.Resources, My_Resource_Iterator);
	if not is_empty (sys.Resources) then 
	loop
	current_element (sys.Resources, A_Resource, My_Resource_Iterator);
	
	Append_Text (Gtk_Combo_Box(my_combo_dependencies_resource), To_String(A_Resource.name));
	exit when is_last_element (sys.Resources, My_Resource_Iterator);
		next_element (sys.Resources, My_Resource_Iterator);
	end loop;
	else
	Show_Message_Box (Lb_Define_Resources_Before (Current_Language));
	end if;

	my_combo_task_resource := Get_Object(Builder, "combobox14");
	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_combo_task_resource), 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_bb_task := Get_Object(Builder, "combobox15");
	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_combo_bb_task), 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_bb_buffer := Get_Object(Builder, "combobox17");
	reset_iterator (sys.Buffers, My_Buffer_Iterator);
	if not is_empty (sys.Buffers) then 
	loop
	current_element (sys.Buffers, A_Buffer, My_Buffer_Iterator);
	
	Append_Text (Gtk_Combo_Box(my_combo_bb_buffer), To_String(A_Buffer.name));
	exit when is_last_element (sys.Buffers, My_Buffer_Iterator);
		next_element (sys.Buffers, My_Buffer_Iterator);
	end loop;
	else
	Show_Message_Box (Lb_Define_Buffers_Before (Current_Language));
	end if;

	liststore:= Get_Object(Builder, "liststore1");
	reset_iterator (sys.dependencies.Depends, My_Iterator_dep);
	if not is_empty (sys.dependencies.Depends) then
		loop
		current_element (sys.dependencies.Depends, An_Dependency, My_Iterator_dep);
		Append(Gtk_List_Store(liststore), tree_iter);

		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 0, 
		To_String(get_compatible_dependencies(An_Dependency.type_of_dependency)));

		case An_Dependency.type_of_dependency is 
		
		when precedence_dependency =>  
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, 
			To_String (An_Dependency.precedence_sink.name));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 3, 
			To_String (An_Dependency.precedence_source.name));

		when queuing_buffer_dependency => 
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, 
			To_String (An_Dependency.buffer_dependent_task.name));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 2, 
			to_string(get_compatible_orientation(An_Dependency.buffer_orientation)));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 3, 
			To_String (An_Dependency.buffer_dependency_object.name));

		when communication_dependency =>
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, 
			To_String (An_Dependency.communication_dependent_task.name));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 2, 
			to_string(get_compatible_orientation(An_Dependency.communication_orientation)));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 3, 
			To_String (An_Dependency.communication_dependency_object.name));
	
		when time_triggered_communication_dependency =>
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, 
			To_String (An_Dependency.time_triggered_communication_sink.name));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 2, 
			to_string(get_compatible_time_trigerred(An_Dependency.timing_property)));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 3, 
			To_String (An_Dependency.time_triggered_communication_source.name));

		when resource_dependency =>
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, 
			To_String (An_Dependency.resource_dependency_resource.name));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 3, 
			To_String (An_Dependency.resource_dependency_task.name));

		when black_board_Buffer_dependency =>
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, 
			To_String (An_Dependency.black_board_dependent_task.name));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 2, 
			to_string(get_compatible_orientation(An_Dependency.black_board_orientation)));
			Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 3, 
			To_String (An_Dependency.black_board_dependency_object.name));
	
		end case;

		exit when is_last_element (sys.dependencies.Depends, My_Iterator_dep);
		next_element (sys.dependencies.Depends, My_Iterator_dep);
	        end loop;
	end if;

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

	Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_treeview2_cursor_changed", 
	Handler      => show_lign_precedence_selected'Access);

	Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button7_clicked", 
	Handler      => add_view_precedence'Access); 

	Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button9_clicked", 
	Handler      => add_view_queuing'Access); 

	Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button11_clicked", 
	Handler      => add_view_communication'Access);

	Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button13_clicked", 
	Handler      => add_view_time'Access);

	Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button15_clicked", 
	Handler      => add_view_resource'Access);

	Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button17_clicked", 
	Handler      => add_view_black'Access);

	Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button6_clicked", 
	Handler      => delete_view_precedence'Access);  


	Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button2_clicked", 
	Handler      => add_dependencies'Access);

	Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button4_clicked", 
	Handler      => delete_dependencies'Access);  

	Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button1_clicked", 
	Handler      => close_widget'Access);

	Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button3_clicked", 
	Handler      => cancel_widget'Access);

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

end show_dependencies_widget;

end graphical_editor.dependencies;