Ada Thread Switching Using GtkAda - multithreading

Question

A task I created doesn't appear to be relinquishing control so that the main thread will run. I'm not sure why. Since this is my first attempt to use multithreading in Ada (under GNAT with GtkAda), I am sure I am missing some basic principle here.
My main looks like this:
procedure Main is
begin
Test_Gui.Gui_Task.Gui_Initialize;
Test_Gui.Simple_Switch_Test;
Msg("Done");
end;
In the package Test_Gui, the spec and body code look like this:
task type Gui_Type is
entry Gui_Initialize;
entry Gui_Reset_SwitCh_To_1;
entry Gui_Display_Message(Message : String);
entry Gui_Write_Debug;
end Gui_Type;
Gui_Task : Gui_Type;
and
task body Gui_Type is
begin
loop
select
accept Gui_Initialize do
Initialize;
end Gui_Initialize;
or
accept Gui_Reset_Switch_To_1 do
Reset_Switch_To_1;
end Gui_Reset_Switch_To_1;
or
accept Gui_Display_Message (Message : in String) do
Display_Message(Message);
end Gui_Display_Message;
or
accept Gui_Write_Debug do
Debug_Label.Set_Label(Debug_Label_Text);
end Gui_Write_Debug;
else
Gdk.Threads.Enter;
Dead := Gtk.Main.Main_Iteration;
Gdk.Threads.Leave;
delay 0.01;
end select;
end loop;
end Gui_Type;
The second method, Simple_Switch_Test, called from main is this, which invokes a call to the GUI task from within Redisplay_Item_And_Get_Switches.
procedure Simple_Switch_Test is
Text : String(1..80) := (others => ' ');
Msg : String(1..16);
begin
loop
Count := Count + 1;
Copy_String(Integer'Image(Count), Text);
for I in 1..16 loop
Msg(I) := Text(I);
end loop;
Redisplay_Item_And_Get_Switches(Msg);
Copy_String("some stuff.."), Debug_Label_Text );
Gui_Task.Gui_Write_Debug;
delay 0.01;
end loop;
end;
Initialization works and the GUI functions, even with its callbacks working. However, after the first call to Redisplay_Item_And_Get_Switches from Simple_Switch_Test puts the code into the GUI task loop, it never leaves the else clause, except to handle the callbacks.
Consequently, it never gets to the call to Gui_Task.Gui_Write_Debug and continue that code in the main task.
I have verified this in the debugger.
I thought the delays in each loop would suspend the associated task, but I obviously don't understand it correctly. Is this code fixable without too many changes? (I'm hoping I got the basic skeleton of tasking implemented right.) What is missing or wrong with it?

Answer 1

The problem I see with this is that Gtkada is layered on top of a non-Ada product, Gtk, that doesn't support Ada's tasking model.
According to Dmitry Kazakov's "GTKAda Contributions" library :
GTK+ is known to be task unsafe. In particular, all calls need to be made from the same task (thread).
I have no better suggestion than to read his documentation at that link, specifically the first section "1. Tasking with GTK+" which contains an example in Section 1.1, and - if you find it helpful - download and use his support library.
(If people think this should be a comment, I'll make it so)