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 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(graphical_editor.Draw_scheduling_pkg.Draw_Scheduling); return false; end Expose; procedure Draw_Scheduling(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 .... 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; -- ajouter a cette procedure text ... plus la peine ... 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.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.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.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.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.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.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); --set_offset(iter, Gint(line_Number)); Get_Iter_At_Line (my_buf_2, Iter, Gint(line_Number)); Insert (my_buf_2, iter, to_string(Response_List.entries (0).title)); line_Number := line_Number +1; -- Write_Title (Schedule_From_To.Text, Response_List.entries (0).title); --Set_Text(my_buf_2, to_string(Response_List.entries (0).title)); for J in 0 .. Response_List.nb_entries - 1 loop Get_Iter_At_Line (my_buf_2, Iter, Gint(line_Number)); Insert (my_buf_2, iter, to_string(Response_List.entries (J).text)); line_Number := line_Number +1; -- Write_Text (Schedule_From_To.Text, Response_List.entries (J).text); --set_text(my_buf_2, to_string(Response_List.entries (J).text)); end loop; end Call_Processor_Analysis; 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.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.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.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.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.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.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)); 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 (Schedule_From_To.Text, Response_List); -- gerer l'affichage d'une table ici ... --set_text(my_buf_2, to_string(Response_List)); --puis next ... for J in 0 .. Response_List.nb_entries - 1 loop -- il s'agit en réalité ici de gérer la police des titres et du texte ... -- Write_Title (A_Text, Response_List.entries (J).title); -- Write_Text (A_Text, Response_List.entries (J).text); Get_Iter_At_Line (my_buf_2, Iter, Gint(line_Number)); Insert (my_buf_2, iter, to_string(Response_List.entries (J).title)); line_Number := line_Number +1; Get_Iter_At_Line (my_buf_2, Iter, Gint(line_Number)); Insert (my_buf_2, iter, to_string(Response_List.entries (J).text)); line_Number := line_Number +1; end loop; --gtk_New (graphical_editor.scheduling_simulation_callbacks.Draw_Scheduling); --graphical_editor.scheduling_simulation_callbacks.Draw_Scheduling.Buffer := Gtk_Double_Buffer(my_area_1); --ajouter ici le package qui contient draw_time_line (Draw_Scheduling_Pkg) cb.Connect (Gtk_Drawing_Area(my_area), "expose_event", cb.To_Marshaller(Expose'Access)); Draw_Time_Line_cbk(graphical_editor.Draw_scheduling_pkg.Draw_Scheduling); --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 (Schedule_From_To.Text, Response_List); for J in 0 .. Response_List.nb_entries - 1 loop -- il s'agit en réalité ici de gérer la police des titres et du texte ... -- Write_Title (A_Text, Response_List.entries (J).title); -- Write_Text (A_Text, Response_List.entries (J).text); Get_Iter_At_Line (my_buf_2, Iter, Gint(line_Number)); Insert (my_buf_2, iter, to_string(Response_List.entries (J).title)); line_Number := line_Number +1; Get_Iter_At_Line (my_buf_2, Iter, Gint(line_Number)); Insert (my_buf_2, iter, to_string(Response_List.entries (J).text)); line_Number := line_Number +1; end loop; end if; end Call_Customized_Simulation; 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); --my_widget:=Get_Object(Object, "window1"); --Unref(my_widget); 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; -- Hide (Schedule_From_To); --my_widget:=Get_Object(Object, "window1"); --Unref(my_widget); --return false; end Draw_Direct_Scheduling; procedure Draw_Time_Line_cbk(Draw_Scheduling : out Draw_Scheduling_Access) 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); 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-*-*-*-*-*-*"); Draw_Time_Line(Draw_Scheduling, sys.tasks, sys.resources, sys.messages, sys.buffers, Stop_Draw, Start_Draw, Framework.Sched); 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"); Unref(my_widget); Hide(Gtk_Widget(my_widget)); end Close_Widget; end graphical_editor.scheduling_simulation_draw_callbacks;