Indy server poll thread

Hi all,

I want to create a thread for my application that has a TIdTCPClient that polls the server for messages. This polling needs to continue when my application is doing a lengthy process that is why I created the TIdTCPClient inside a thread. I do not want to call Application.ProcessMessages since this can disturb the length process.

I have tried first without the PeekMessage instruction in the source below but the Thread did not poll anymore during my lengthy call (Button2Click). Now when I put a PeekMessage (which does not remove a message) my thread keeps on polling. Now I don't want this PeekMessage either, I just want my thread to keep on polling.

My question is how can this be? The PeekMessage should not do anything. And secondly: is there a way to program this behaviour without calling PeekMessage in my main thread?

My guess is that the PeekMessage gives windows the chance to forward messages to my thread. Will this work for all Windows versions?

Can someway explain what is going on here?

Thanks Jacco

Here is the source for the client:

unit uClient;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  IdAntiFreezeBase, IdAntiFreeze, IdBaseComponent, IdComponent,
  IdTCPConnection, IdTCPClient, StdCtrls, IdThread, ComCtrls;

type
  TPollThread = class(TIdThread)
  private
    fClient: TIdTCPClient;
  protected
    procedure Run; override;
  public
    constructor Create(ACreateSuspended: Boolean = True); override;
    destructor Destroy; override;
  end;

  TSyncSendResult = class
  private
    fResult: string;
    procedure Sync;
  public
    class procedure SendResult(aThread: TIdThread; aResult: string);
  end;

  TfrmClient = class(TForm)
    Button1: TButton;
    Memo1: TMemo;
    Button2: TButton;
    pbProgress: TProgressBar;
    Label1: TLabel;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { Private declarations }
    fPoll: TPollThread;
  public
    { Public declarations }
  end;

var
  frmClient: TfrmClient;

implementation

{$R *.DFM}

{ TPollThread }

constructor TPollThread.Create(ACreateSuspended: Boolean);
begin
  fClient := TIdTCPClient.Create(nil);
  // setup client
  with fClient do
  begin
    Host := '127.0.0.1';
    Port := 45000;
  end;
  FreeOnTerminate := True;
  inherited Create(ACreateSuspended);
end;

destructor TPollThread.Destroy;
begin
  fClient.Free;
  inherited Destroy;
end;

procedure TPollThread.Run;
var
  lsResult: string;
begin
  // try to connect
  if not fClient.Connected then
  begin
    try
      fClient.Connect;
    except
    end;
    if fClient.Connected then
      TSyncSendResult.SendResult(Self, 'Connection established')
    else
      TSyncSendResult.SendResult(Self, 'Connection failed');
  end;
  // try to acquire server messages
  if fClient.Connected then
  begin
    try
      fClient.WriteLn('POLL');
      lsResult := fClient.ReadLn;
      if lsResult = 'NOMESSAGES' then
        TSyncSendResult.SendResult(Self, 'No messages');
    except
      fClient.Disconnect;
    end;
  end;
  // send queued messages
  // todo
end;

{ TSyncSendResult }

class procedure TSyncSendResult.SendResult(aThread: TIdThread; aResult: string);
begin
  with Create do
  try
    fResult := aResult;
    aThread.Synchronize(Sync);
  finally
    Free;
  end;
end;

var
  giCount: LongInt = 0;

procedure TSyncSendResult.Sync;
begin
  frmClient.Memo1.Lines.Add(fResult);
  frmClient.Label1.Caption := IntToStr(giCount);
  Inc(giCount);
end;

{ TfrmClient }

procedure TfrmClient.Button1Click(Sender: TObject);
begin
  fPoll := TPollThread.Create(False);
end;

procedure TfrmClient.Button2Click(Sender: TObject);
var
  liCount: Integer;
  Msg: TMsg;
begin
  liCount := 0;
  while liCount < 10000 do
  begin
    if pbProgress.Position = 100 then
      pbProgress.Position := 0
    else
      pbProgress.Position := pbProgress.Position + 1;
    // if this is removed the thread will stop polling
    PeekMessage(Msg, 0, 0, 0, PM_NOREMOVE);
    Inc(liCount);
  end;
end;

end.