🚀 go-pugleaf

> OnException is triggered in the context of the connection's thread.
> OnListenException is triggered in the context of the thread that
> TIdTCPServer creats for a particular Binding that is listening for
> incoming connections.
> ...
> In Indy 9, simply derive from TIdPeerThread and then set the server's
> ThreadClass property before activating the server.  TIdPeerThread is a
> TThread descendant, so you have access to its Synchronize() method.
> ...
> Alternatively, derive from TIdSync instead of TIdPeerThread/TIdContext,
> and override the virtual DoSynchronize() method.

Thanks again for the explanation and examples.  The first method you 
discussed, making a TIdPeerThread descendant, was clearer (maybe just 
because it's more similar to other thread handling that I've done before). 
I'd like to use that method, but it only seems to take care of the 
TIdPeerThread cases.  Since OnListenException takes place in the context of 
a TIdListenerThread instead, would it not work there?

In your TIdSync descendant, I kind of got lost on what ended up happening to 
the string.  It had been loaded into Sync->FStr when you got to the line:
   Sync->Synchronize();
but then I'm not entirely sure how to make Synchronize() do anything with 
it.  At some point it needs to reach my form where I can display it.  So 
would that go with something like:

    void __fastcall TMySync::DoSynchronize()
    {
        Form1->HandleStringInput(FStr);
    }

and:

    void __fastcall TForm1::HandleStringInput(AnsiString Message)
    {
        Memo1->Lines->Add(Message);
    }

(Actually, if I'm understanding this correctly, those could be combined into 
just the DoSynchronize method, but I prefer keeping them separate just to 
let TForm1 be where the decision is made of what to do with the message.  I 
think it looks clearer that way.)

Is that how this works, or am I (yet again) looking at this completely 
wrong.  Basically, will Sync->Synchronize() take care of whatever it needs 
to do to make sure the threads actually are in synch, then call my 
DoSynchronize() function in a context where it's safe to do so?

(Part of my problem in understanding this is that I don't really understand 
quite what Synchronize() does in the first place.  I know that it's 
necessary, and a bit about why and when it's necessary, but that's about as 
far as I got in understanding it.  Not quite knowing how it does what it 
needs to makes me a bit leery of overriding anything too closely connected 
with it.)