with Gtk.Menu_Item; use Gtk.Menu_Item; with Gtk; use Gtk; with Gtk.Main; use Gtk.Main; with Glib.Error; use Glib.Error; with Gtk.Widget; use Gtk.Widget; with Gtk.Dialog; use Gtk.Dialog; with Gtk.About_Dialog; use Gtk.About_Dialog; with Gtk.Label; use Gtk.Label; with Ada.Text_IO; use Ada.Text_IO; with Glib; use Glib; with Glib.Object; use Glib.Object; with graphical_editor.user_message; use graphical_editor.user_message; with Translate; use Translate; with Framework_Config; use Framework_Config; with Gtk.Text_Buffer; use Gtk.Text_Buffer; with generic_package_widget; use generic_package_widget; --with Draw_Scheduling_Pkg; use Draw_Scheduling_Pkg; --with Draw_Time_Line_From_To_Pkg; use Draw_Time_Line_From_To_Pkg; with Framework; use Framework; with Call_Framework; use Call_Framework; with Call_Framework_Interface; use Call_Framework_Interface; with Project; use Project; with Processors; use Processors; with Processor_Set; use Processor_Set; use Processor_Set.Generic_Processor_Set; with Task_Set; use Task_Set; use Task_Set.Generic_Task_Set; with Resource_Set; use Resource_Set; use Resource_Set.Generic_Resource_Set; with Message_Set; use Message_Set; use Message_Set.Generic_Message_Set; with Buffer_Set; use Buffer_Set; use Buffer_Set.Generic_Buffer_Set; with graphical_editor.Select_Time_Line_Pkg; use graphical_editor.Select_Time_Line_Pkg; with Editor_Config; use Editor_Config; with time_unit_events.extended; use time_unit_events.extended; --with schedule_from_to_pkg; use schedule_from_to_pkg; --with Schedule_From_To_Pkg.Callbacks; use Schedule_From_To_Pkg.Callbacks; with Ada.Strings.Unbounded; use Ada.Strings.Unbounded; with Call_Framework; use Call_Framework; with Call_Framework_Interface; use Call_Framework_Interface; use Call_Framework_Interface.Framework_Request_Package; use Call_Framework_Interface.Framework_Response_Package; with Parameters; use Parameters; with Parameters.extended; use Parameters.extended; use Parameters.Framework_Parameters_Table_Package; with Call_Scheduling_Framework; use Call_Scheduling_Framework; with Multiprocessor_Services; use Multiprocessor_Services; with Multiprocessor_Services_Interface; use Multiprocessor_Services_Interface; use Multiprocessor_Services_Interface.Scheduling_Result_Per_Processor_Package; with Framework_Config; use Framework_Config; with strings; use strings; with Project; use Project; with unbounded_strings; use unbounded_strings; --with Mmi_Tools; use Mmi_Tools; with Translate; use Translate; --with Text_Tools; use Text_Tools; with Processors; use Processors; with Processor_Set; use Processor_Set; use Processor_Set.Generic_Processor_Set; with Task_Set; use Task_Set; use Task_Set.Generic_Task_Set; with Resource_Set; use Resource_Set; use Resource_Set.Generic_Resource_Set; with Message_Set; use Message_Set; use Message_Set.Generic_Message_Set; with Buffer_Set; use Buffer_Set; use Buffer_Set.Generic_Buffer_Set; --with Select_Time_Line_Pkg; use Select_Time_Line_Pkg; with Editor_Config; use Editor_Config; --with Events; use Events; with time_unit_events; use time_unit_events; with time_unit_events.extended; use time_unit_events.extended; with graphical_editor.scheduling_simulation_callbacks; use graphical_editor.scheduling_simulation_callbacks; with Gtk.Text_Iter; use Gtk.Text_Iter; --with Draw_Scheduling_Pkg; use Draw_Scheduling_Pkg; with graphical_editor.Draw_Scheduling_Pkg; use graphical_editor.Draw_Scheduling_Pkg; with graphical_editor.message_text; use graphical_editor.message_text; with Gtk.Drawing_Area; use Gtk.Drawing_Area; with Double_Buffer; use Double_Buffer; with Gtk.Handlers; use Gtk.Handlers; with Gdk.Drawable; use Gdk.Drawable; with Gdk.font; use Gdk.font; with Gdk.Color; use Gdk.Color; with Gdk.GC; use Gdk.GC; with Gdk.Event; use Gdk.Event; package body graphical_editor.scheduling_simulation_draw_callbacks is Draw_From, Draw_Upto, Schedule_To : Unbounded_String; Last_Period : constant Natural := Framework_Config.Max_Scheduling_Period - 1; Max_Period : Natural := 0; Start_Draw : Integer := 0; Stop_Draw : Integer := 0; Ok : Boolean; iter : Gtk_Text_Iter; line_Number : integer := 0; package Cb is new Gtk.Handlers.Return_Callback(Gtk.Drawing_Area.Gtk_Drawing_Area_Record, boolean); use Cb; function Expose (W : access Gtk.Drawing_Area.Gtk_Drawing_Area_Record'Class) return boolean is begin Draw_Time_Line_cbk(Draw_Scheduling); --Draw_Time_Line_cbk; return false; end Expose; procedure Draw_Scheduling_proc(Object : access Gtkada_Builder_Record'Class) is Draw_From, Draw_To : Unbounded_String; Draw_From_Time : Integer := 0; Draw_To_Time : Integer := 0; Ok : Boolean; begin graphical_editor.scheduling_simulation_draw_callbacks.Close_Widget(Object); Draw_From := get_value_buffer_string(Gtk_Text_Buffer(Get_Object(Object, "textbuffer2"))); Draw_To := get_value_buffer_string(Gtk_Text_Buffer(Get_Object(Object, "textbuffer3"))); to_integer (Draw_From, Draw_From_Time, Ok); if not Ok then Show_Message_Box (Lb_Double_Quote & Lb_Draw_From (Current_Language) & Lb_Double_Quote & Lb_Must_Be_Numeric (Current_Language)); return; end if; to_integer (Draw_To, Draw_To_Time, Ok); if not Ok then Show_Message_Box (Lb_Double_Quote & Lb_Draw_To (Current_Language) & Lb_Double_Quote & Lb_Must_Be_Numeric (Current_Language)); return; end if; if (Draw_To_Time <= 0) then Show_Message_Box (Lb_Double_Quote & Lb_Draw_To (Current_Language) & Lb_Double_Quote & Lb_Must_Be (Current_Language) & To_Unbounded_String (" > 0")); return; end if; if (Draw_From_Time < 0) then Show_Message_Box (Lb_Double_Quote & Lb_Draw_From (Current_Language) & Lb_Double_Quote & Lb_Must_Be (Current_Language) & To_Unbounded_String (" >= 0")); return; end if; if (Draw_From_Time > Draw_To_Time) then Show_Message_Box (Lb_Double_Quote & Lb_Draw_From (Current_Language) & Lb_Must_Be (Current_Language) & Lb_Double_Quote & To_Unbounded_String (" <= ") & Lb_Double_Quote & Lb_Draw_To (Current_Language) & Lb_Double_Quote); return; end if; if (Draw_To_Time - Draw_From_Time > 1500) then Show_Message_Box (Lb_Draw_Time_Line_Too_Large (Current_Language)); return; end if; -- pour rappel, ici on a remplace Draw_Time_Line_From_To par Draw_scheduling_pkg -- c'est le draw_scheduling qui est l'interface du dessus .... cb.Connect (Gtk_Drawing_Area(my_area), "expose_event", cb.To_Marshaller(Expose'Access)); Draw_Time_Line_cbk(Draw_Scheduling); --Draw_Time_Line_cbk; --Draw_Time_Line -- (graphical_editor.Draw_scheduling_pkg.Draw_Scheduling, --voir si en mettant ici mon buffer ça ira ... -- Sys.Tasks, --Sys.Resources, -- Sys.Messages, -- Sys.Buffers, -- Draw_To_Time, -- Draw_From_Time, -- Framework.Sched); end Draw_Scheduling_proc; procedure Call_Processor_Analysis (Name : Unbounded_String) is Response_List : Framework_Response_Table; Request_List : Framework_Request_Table; A_Request : Framework_Request; A_Param : Parameter_Ptr; begin initialize (Response_List); initialize (Request_List); if Preemption_From_Simulation then Initialize (A_Request); A_Request.target := Name; A_Request.statement := Scheduling_Simulation_Preemption_Number; add (Request_List, A_Request); end if; if Context_Switch_From_Simulation then Initialize (A_Request); A_Request.target := Name; A_Request.statement := Scheduling_Simulation_Context_Switch_Number; add (Request_List, A_Request); end if; if (Response_Time_From_Simulation (Worst_Case) or Response_Time_From_Simulation (Best_Case) or Response_Time_From_Simulation (Average_Case) or Response_Time_From_Simulation (Plot_Case)) then Initialize (A_Request); A_Param := new Parameter (Boolean_Parameter); A_Param.parameter_name := To_Unbounded_String ("worst_case"); if Response_Time_From_Simulation (Worst_Case) then A_Param.boolean_value := True; else A_Param.boolean_value := False; end if; add (A_Request.param, A_Param); A_Param := new Parameter (Boolean_Parameter); A_Param.parameter_name := To_Unbounded_String ("best_case"); if Response_Time_From_Simulation (Best_Case) then A_Param.boolean_value := True; else A_Param.boolean_value := False; end if; add (A_Request.param, A_Param); A_Param := new Parameter (Boolean_Parameter); A_Param.parameter_name := To_Unbounded_String ("average_case"); if Response_Time_From_Simulation (Average_Case) then A_Param.boolean_value := True; else A_Param.boolean_value := False; end if; add (A_Request.param, A_Param); A_Request.target := Name; A_Request.statement := Scheduling_Simulation_Response_Time; add (Request_List, A_Request); end if; if (Blocking_Time_From_Simulation (Worst_Case) or Blocking_Time_From_Simulation (Best_Case) or Blocking_Time_From_Simulation (Average_Case) or Blocking_Time_From_Simulation (Plot_Case)) then Initialize (A_Request); A_Param := new Parameter (Boolean_Parameter); A_Param.parameter_name := To_Unbounded_String ("worst_case"); if Blocking_Time_From_Simulation (Worst_Case) then A_Param.boolean_value := True; else A_Param.boolean_value := False; end if; add (A_Request.param, A_Param); A_Param := new Parameter (Boolean_Parameter); A_Param.parameter_name := To_Unbounded_String ("best_case"); if Blocking_Time_From_Simulation (Best_Case) then A_Param.boolean_value := True; else A_Param.boolean_value := False; end if; add (A_Request.param, A_Param); A_Param := new Parameter (Boolean_Parameter); A_Param.parameter_name := To_Unbounded_String ("average_case"); if Blocking_Time_From_Simulation (Average_Case) then A_Param.boolean_value := True; else A_Param.boolean_value := False; end if; add (A_Request.param, A_Param); A_Request.target := Name; A_Request.statement := Scheduling_Simulation_Blocking_Time; add (Request_List, A_Request); end if; Sequential_Framework_Request (Sys, Request_List, Response_List); Write_Title(Response_List); Write_Text(Response_List); end Call_Processor_Analysis; procedure Call_Uncustomized_Simulation is Response_List : Framework_Response_Table; Request_List : Framework_Request_Table; A_Request : Framework_Request; A_Param : Parameter_Ptr; begin Initialize (A_Request); A_Request.statement := Scheduling_Simulation_Time_Line; A_Param := new Parameter (Integer_Parameter); A_Param.parameter_name := To_Unbounded_String ("period"); A_Param.integer_value := Max_Period; add (A_Request.param, A_Param); A_Param := new Parameter (Boolean_Parameter); A_Param.parameter_name := To_Unbounded_String ("schedule_with_offsets"); A_Param.boolean_value := Schedule_With_Offsets; add (A_Request.param, A_Param); A_Param := new Parameter (Boolean_Parameter); A_Param.parameter_name := To_Unbounded_String ("schedule_with_precedencies"); A_Param.boolean_value := Schedule_With_Precedencies; add (A_Request.param, A_Param); A_Param := new Parameter (Boolean_Parameter); A_Param.parameter_name := To_Unbounded_String ("schedule_with_resources"); A_Param.boolean_value := Schedule_With_Resources; add (A_Request.param, A_Param); A_Param := new Parameter (Boolean_Parameter); A_Param.parameter_name := To_Unbounded_String ("predictable"); A_Param.boolean_value := Is_Global_Predictable_Seed; add (A_Request.param, A_Param); if Has_Global_Seed then A_Param := new Parameter (Integer_Parameter); A_Param.parameter_name := To_Unbounded_String ("seed_value"); A_Param.integer_value := Global_Seed_Value; add (A_Request.param, A_Param); end if; for I in Time_Unit_Event_Type'Range loop A_Param := new Parameter (Boolean_Parameter); --A_Param.name := To_Unbounded_String (to_lower (I'Img)); A_Param.parameter_name := To_Unbounded_String (to_lower (I'Img)); if Generate_Events (I) then A_Param.boolean_value := True; else A_Param.boolean_value := False; end if; add (A_Request.param, A_Param); end loop; add (Request_List, A_Request); Initialize (A_Request); A_Request.target := empty_string; A_Request.statement := Scheduling_Simulation_Basics; add (Request_List, A_Request); Sequential_Framework_Request (Sys, Request_List, Response_List); Write_Title_And_Text (Response_List); cb.Connect (Gtk_Drawing_Area(my_area), "expose_event", cb.To_Marshaller(Expose'Access)); Draw_Time_Line_cbk(Draw_Scheduling); --Draw_Time_Line_cbk; --Draw_Time_Line --(Schedule_From_To.Draw_Scheduling, -- Sys.Tasks, -- Sys.Resources, -- Sys.Messages, -- Sys.Buffers, -- Stop_Draw, -- Start_Draw, -- Call_Scheduling_Framework.Sched); end Call_Uncustomized_Simulation; procedure Call_Customized_Simulation is A_Processor : Generic_Processor_Ptr; My_Processor_Iterator : Processors_Iterator; Response_List : Framework_Response_Table; Request_List : Framework_Request_Table; A_Request : Framework_Request; A_Param : Parameter_Ptr; begin Initialize (A_Request); A_Request.statement := Scheduling_Simulation_Time_Line; A_Param := new Parameter (Integer_Parameter); A_Param.parameter_name := To_Unbounded_String ("period"); A_Param.integer_value := Max_Period; add (A_Request.param, A_Param); A_Param := new Parameter (Boolean_Parameter); A_Param.parameter_name := To_Unbounded_String ("schedule_with_offsets"); A_Param.boolean_value := Schedule_With_Offsets; add (A_Request.param, A_Param); A_Param := new Parameter (Boolean_Parameter); A_Param.parameter_name := To_Unbounded_String ("schedule_with_precedencies"); A_Param.boolean_value := Schedule_With_Precedencies; add (A_Request.param, A_Param); A_Param := new Parameter (Boolean_Parameter); A_Param.parameter_name := To_Unbounded_String ("schedule_with_resources"); A_Param.boolean_value := Schedule_With_Resources; add (A_Request.param, A_Param); A_Param := new Parameter (Boolean_Parameter); A_Param.parameter_name := To_Unbounded_String ("predictable"); A_Param.boolean_value := Is_Global_Predictable_Seed; add (A_Request.param, A_Param); if Has_Global_Seed then A_Param := new Parameter (Integer_Parameter); A_Param.parameter_name := To_Unbounded_String ("seed_value"); A_Param.integer_value := Global_Seed_Value; add (A_Request.param, A_Param); end if; for I in Time_Unit_Event_Type'Range loop A_Param := new Parameter (Boolean_Parameter); A_Param.parameter_name := To_Unbounded_String (to_lower (I'Img)); if Generate_Events (I) then A_Param.boolean_value := True; else A_Param.boolean_value := False; end if; add (A_Request.param, A_Param); end loop; add (Request_List, A_Request); Sequential_Framework_Request (Sys, Request_List, Response_List); -- Put to the screen the resulting event table -- if Schedule_And_Display_Event_Table then -- Display_Scheduling (Call_Scheduling_Framework.Sched); Display_Scheduling (Framework.Sched); end if; Write_Title_And_Text(Response_List); --cb.Connect (Gtk_Drawing_Area(my_area), "expose_event", cb.To_Marshaller(Expose'Access)); Draw_Time_Line_cbk(Draw_Scheduling); --Draw_Time_Line_cbk; --Draw_Time_Line --(--Schedule_From_To.Draw_Scheduling, -- le pb ici, c'est qu'il faut lui passer le draw_scheduling qui vient du package schedule_from_to ... voir comment je peux le fabriquer, de la meme façon que le text que j'ai recuperer de schedule_from_to.text ... --Draw_scheduling_pkg.Draw_Scheduling, --graphical_editor.scheduling_simulation_callbacks.Draw_Scheduling, -- Sys.Tasks, -- Sys.Resources, -- Sys.Messages, -- Sys.Buffers, -- Stop_Draw, -- Start_Draw, --Framework.Sched); -- export event table in the targeted XML file -- if Schedule_And_Export_Event_Table then Write_To_Xml_File (--Call_Scheduling_Framework.Sched, Framework.Sched, Sys, Xml_Event_Table_File_Name); end if; if Schedule_All_Processeurs = False then Call_Processor_Analysis (Last_Selected_Processor); else reset_iterator (Sys.Processors, My_Processor_Iterator); loop current_element (Sys.Processors, A_Processor, My_Processor_Iterator); Call_Processor_Analysis (A_Processor.name); exit when is_last_element (Sys.Processors, My_Processor_Iterator); next_element (Sys.Processors, My_Processor_Iterator); end loop; end if; -- Now run, event analyzers, -- if Run_Event_Analyzer_From_Simulation then initialize (Response_List); initialize (Request_List); Initialize (A_Request); A_Request.statement := Scheduling_Simulation_Run_Event_Handler; add (Request_List, A_Request); Sequential_Framework_Request (Sys, Request_List, Response_List); Write_Title_And_Text(Response_List); end if; end Call_Customized_Simulation; --en fait, le call_uncostomized correspond a l'appel direct, et le call customized recupere les valeurs du dessin ... fournit par l'utilisateur .. --donc ajouter ici un call uncostomized .. et voir pourquoi mes valeurs sont reinitialisees ... je suis sur qu'il s'agit des proprietes --du draw scheduling qui ne sont pas raz ?? procedure Call_Simulation is begin -- According to from when the scheduling simulation is demanded -- by the user, we build a different request -- --if Schedule_From_To.Customized_Simulation then --Call_Customized_Simulation; -- else Call_Uncustomized_Simulation; -- end if; end Call_Simulation; --function Draw_Direct_Scheduling_cbk (Object : access Gtkada_Builder_Record'Class) return boolean is -- pragma Unreferenced (Object); --begin -- Draw_Direct_Scheduling(Object); --null; --Draw_From := get_value_buffer_string(Gtk_Text_Buffer(Get_Object(Object, "textbuffer2"))); -- return false; --end Draw_Direct_Scheduling_cbk; procedure Draw_Direct_Scheduling(Object : access Gtkada_Builder_Record'Class) is pragma Unreferenced (Object); my_widget : GObject; Object_Number : Natural := 0; begin --graphical_editor.scheduling_simulation_draw_callbacks.Close_Widget(Object); hide(gtk_widget(get_object(object, "window1"))); Draw_From := get_value_buffer_string(Gtk_Text_Buffer(Get_Object(Object, "textbuffer2"))); Draw_Upto := get_value_buffer_string(Gtk_Text_Buffer(Get_Object(Object, "textbuffer3"))); Schedule_To := get_value_buffer_string(Gtk_Text_Buffer(Get_Object(Object, "textbuffer1"))); to_natural (Draw_Upto, Stop_Draw, Ok); if not Ok then Show_Message_Box (Lb_Double_Quote & Lb_Draw_To (Current_Language) & Lb_Double_Quote & Lb_Must_Be_Numeric (Current_Language)); return; -- return false; end if; to_integer (Draw_From, Start_Draw, Ok); if not Ok then Show_Message_Box (Lb_Double_Quote & Lb_Draw_From (Current_Language) & Lb_Double_Quote & Lb_Must_Be_Numeric (Current_Language)); return; --return false; end if; to_integer (Schedule_To, Max_Period, Ok); if not Ok then Show_Message_Box (Lb_Double_Quote & Lb_Schedule_To (Current_Language) & Lb_Double_Quote & Lb_Must_Be_Numeric (Current_Language)); return; --return false; end if; if (Max_Period > Last_Period) then Show_Message_Box (Lb_Double_Quote & Lb_Schedule_To (Current_Language) & Lb_Double_Quote & Lb_Must_Be (Current_Language) & To_Unbounded_String (" <= ") & Last_Period'Img); return; --return false; end if; if (Max_Period = 0) then Show_Message_Box (Lb_Double_Quote & Lb_Schedule_To (Current_Language) & Lb_Double_Quote & Lb_Must_Be (Current_Language) & To_Unbounded_String (" > 0")); return; --return false; end if; if (Start_Draw < 0) then Show_Message_Box (Lb_Double_Quote & Lb_Draw_From (Current_Language) & Lb_Double_Quote & Lb_Must_Be (Current_Language) & To_Unbounded_String (" >= 0")); return; --return false; end if; if (Stop_Draw < 0) then Show_Message_Box (Lb_Double_Quote & Lb_Draw_To (Current_Language) & Lb_Double_Quote & Lb_Must_Be (Current_Language) & To_Unbounded_String (" >= 0")); return; --return false; end if; if (Start_Draw > Max_Period) then Show_Message_Box (Lb_Double_Quote & Lb_Draw_From (Current_Language) & Lb_Must_Be (Current_Language) & Lb_Double_Quote & To_Unbounded_String (" <= ") & Lb_Double_Quote & Lb_Schedule_To (Current_Language) & Lb_Double_Quote); return; --return false; end if; if (Stop_Draw - Start_Draw > 1500) then Show_Message_Box (Lb_Draw_Time_Line_Too_Large (Current_Language)); return; --return false; end if; -- Check if we need to select which tasks/messages/buffers -- to display with time lines -- Object_Number := Natural (get_number_of_elements (Sys.Tasks)) + Natural (get_number_of_elements (Sys.Messages)) + Natural (get_number_of_elements (Sys.Buffers)); if Schedule_With_Resources then Object_Number := Object_Number + Natural (get_number_of_elements (Sys.Resources)); end if; -- il s'agit d'appeler ici le gtk_new de select_time_line, pour faire des choix ... -- revenir sur cette partie plus tard ... -- donc appeler pour l'instant directement call_simulation ... --if Object_Number > Editor_Config.Max_Time_Line_To_Display then --Gtk_New (Select_Time_Line, Sys, Call_Simulation'Access); -- Show_All (Select_Time_Line); -- else Call_Simulation; --end if; end Draw_Direct_Scheduling; procedure Draw_Time_Line_cbk(Draw_Scheduling : out Draw_Scheduling_Access) is --procedure Draw_Time_Line_cbk(Draw_Scheduling : Draw_Scheduling_Access) is --procedure Draw_Time_Line_cbk is --Draw_Scheduling : access Draw_Scheduling_Record; --out Draw_Scheduling_Access --Draw_Scheduling : Draw_Scheduling_Access; begin --Gtk_new (Draw_Scheduling); --Draw_Scheduling := new Draw_Scheduling_Record; graphical_editor.Draw_Scheduling_Pkg.Initialize (Draw_Scheduling); --graphical_editor.Draw_Scheduling_Pkg.Initialize; Gdk.GC.Gdk_New (Draw_Scheduling.White_Gc, Get_window(my_area)); Gdk.GC.Set_Foreground (Draw_Scheduling.White_Gc, Gdk.Color.White (Gtk.Widget.Get_Default_Colormap)); Gdk.GC.Gdk_New (Draw_Scheduling.Black_Gc, Get_window(my_area)); Gdk.GC.Set_Foreground (Draw_Scheduling.Black_Gc, Gdk.Color.Black (Gtk.Widget.Get_Default_Colormap)); Draw_Scheduling.Red_Color := Gdk.Color.Parse ("Red"); Gdk.Color.Alloc (Gtk.Widget.Get_Default_Colormap, Draw_Scheduling.Red_Color); Draw_Scheduling.Blue_Color := Gdk.Color.Parse ("Blue"); Gdk.Color.Alloc (Gtk.Widget.Get_Default_Colormap, Draw_Scheduling.Blue_Color); --Load --(Draw_Scheduling.Font, -- "-adobe-helvetica-medium-o-normal--14-140-75-75-p-78-iso8859-1"); --"-*-courier-medium-r-normal-*-*-160-*-*-*-*-*-*"); if Draw_Scheduling.Initialized then Redraw_Time_Line (Draw_Scheduling); --Redraw_Time_Line (graphical_editor.Draw_scheduling_pkg.Draw_Scheduling); else Draw_Time_Line(Draw_Scheduling, sys.tasks, sys.resources, sys.messages, sys.buffers, Stop_Draw, Start_Draw, Framework.Sched); --Draw_Time_Line(graphical_editor.Draw_scheduling_pkg.Draw_Scheduling, sys.tasks, sys.resources, sys.messages, sys.buffers, Stop_Draw, Start_Draw, Framework.Sched); end if; end Draw_Time_Line_cbk; procedure Close_Widget(Object : access Gtkada_Builder_Record'Class) is pragma Unreferenced (Object); my_widget : GObject; begin my_widget:=Get_Object(Object, "window1"); Destroy_cb(Gtk_Widget(my_widget)); gtk.main.main_quit; end Close_Widget; end graphical_editor.scheduling_simulation_draw_callbacks;