Windows Messages in einem (TThread-)Thread empfangen

[Viktorii]

Meine Applikation muss Windows Messages einer anderen Anwendung empfangen. Nach Recherche habe ich das so realisiert:

Als erstes habe ich in meiner MainForm eine private Methode implementiert:

Delphi-Quellcode:

function TMainFormWCM.AppHookFunc (var Message : TMessage) : Boolean;
begin

   if Message.Msg = WM_MEINE_MSG then
  begin
      case Message.WParam of
        …
        …
  end;
end;

Dann habe ich unter FormCreate die Funktion gehookt:

Delphi-Quellcode:

  Application.HookMainWindow(AppHookFunc);

Funktioniert soweit alles super.

Nun möchte ich das Empfangen und Abarbeiten der Messages in einen separaten Thread (mit TThread) auslagern. Wie kann ich eine Methode dort denn entsprechend hooken?

Noch eine Zusatzfrage: Es ist doch so, dass nur der Code in Execute Methode in einem separatem Thread ausgeführt wird, oder? Fügt mal weitere (public-)Methoden zu dem Tthread Objekt hinzu, so werden diese in dem Thread ausgeführt von dem sie aufgerufen worden sind. Hab ich das richtig verstanden?

Vielen Dank

[quendolineDD]

Zitat:

Fügt mal weitere (public-)Methoden zu dem Tthread Objekt hinzu, so werden diese in dem Thread ausgeführt von dem sie aufgerufen worden sind

Nur wenn du in Execute diese Methoden mit Synchronize() aufrufst. Ansonsten läuft die Bearbeitung im Kontext des Threads.

Meiner Meinung nach hat ein Thread keine Nachrichtenschleife, wodurch das abfangen von Nachrichten sich als Schwer erweist.

Zitat:

Nun möchte ich das Empfangen und Abarbeiten der Messages in einen separaten Thread (mit TThread) auslagern. Wie kann ich eine Methode dort denn entsprechend hooken?

Du könntest in AppHookFunc einen Thread starten und ihm die Message übergeben. Damit kehrst du aus der Proc zurück und der Thread arbeitet die Message entsprechend ab.

[fajac]

Nachrichten, die an deine Anwendung (heißt, an deren Hauptfenster) geschickt werden, kannst du nur im Hauptthread bearbeiten.
Wenn es darum geht, selbstdefinierte Nachrichten zwischen zwei Applikationen auszutauschen, kann man das durchaus mit einem Thread machen. Allerdings muss man dann die Nachrichten per "PostThreadMessage" versenden, SendMessage und PostMessage gehen nicht.

P.S.: Was deine Frage zum Aufruf der Methoden eines TThread-Objekts betrifft, hast du Recht: Aufrufe dieser Methoden laufen immer im Kontext des aufrufenden Threads.

[jfheins]

Du könntest einen thread erstellen, der sich ein message-only Fenster erstellt. Damit sollte er dann Fensternachrichten empfangen können.
In der Anwendung kannst du dann ebim erhalten der Nachricht den Inhalt an den Thread weiterschicken (mit postmessage oder so)

Dann kommt die Nachricht zwatr erstmal beim Hauptfenster an, wird aber sofort und mit wenig Zeitverlust weitergeleitet - der Thread kann sich dann abarbeiten...

[himitsu]

Erstmal hat jeder Thread einen eigenen MessagePool.
alle Fensternachrichten, welche per PostMessage verwendet werden, landen in dem Thread-Message-Pool des Threads, worin das Fenster erstellt wurde.

Die passende Nachrichtenschleife der VCL (oder eigene Schleifchen) lesen dann den Pool ihres Threads aus und teilen die Nachrichten erst dann den Fenstern zu.

PS: also kannst du auch ein eigenes Nachtichtennfenster für/in deinen Thread erstellen und mußt dann natürlich eine eigene Nachrichtenbehandlung für diesen Thread implementieren.
Oder du sendest Nachrichten direkt an den Thread (PostThreadMessage), wofür natürlich auch eine Nachrichtenbehandlung erforderlich ist.

[Viktorii]

So, alten Thread ausgebuddelt, aber ich habe genau dieses Problem...

Zitat:

Zitat von himitsu (Beitrag 929580)

also kannst du auch ein eigenes Nachtichtennfenster für/in deinen Thread erstellen und mußt dann natürlich eine eigene Nachrichtenbehandlung für diesen Thread implementieren.

Wie genau geht das?

Ich habe mir mit Neu->Weitere->Thread Objekt das Grundgerüst für einen von TThread abgeleitete Klasse erstellt.

Wie kann ich mir jetzt das Nachtichtenfenster für diese Klasse erstellen, damit ich diesem Thread Nachrichten empfangen kann?

[DeddyH]

Schau Dir mal AllocateHWnd an.

[Viktorii]

So habe ich es versucht:

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
begin
  FMyThread := TMyThread.Create(false);
end;

procedure TForm1.WndProc(var Msg: TMessage);
begin
  if assigned(FMyThread) then
  begin
    OutputDebugString(PWideChar('TForm1.WndProc - Msg: #' + IntToStr(Msg.Msg)));
    PostMessage(FMyThread.GetWNDHandle,Msg.Msg,Msg.WParam,Msg.LParam);
  end;
  inherited;
end;

Delphi-Quellcode:

type
  TMyThread = class(TThread)
  private
    FWNDHandle: Cardinal;
    procedure WndProc(var Msg: TMessage);
  protected
    procedure Execute; override;
  public
    property GetWNDHandle: Cardinal read FWNDHandle;
  end;

implementation

uses
  Windows, SysUtils;

procedure TMyThread.Execute;
begin
  FWNDHandle := AllocateHWnd(WndProc);

  while not Terminated do
  begin
    //suspend();
  end;

  DeallocateHWnd(FWNDHandle);
end;

procedure TMyThread.WndProc(var Msg: TMessage);
begin
  OutputDebugString(PWideChar('TMyThread.WndProc - Msg: #' + IntToStr(Msg.Msg)));
end;

Aber es scheint nichts im Thread anzukommen :(

[Bummi]

probiers mal so

Delphi-Quellcode:

unit Unit2;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TMyThread = class(TThread)
  private
    FWNDHandle: Cardinal;
    procedure WndProc(var Msg: TMessage);
  protected
    procedure Execute; override;

  public
    Constructor Create(CreateSuspended: Boolean);Reintroduce;overload;
    Constructor Create; Reintroduce;overload;
    Destructor Destroy; override;
    property GetWNDHandle: Cardinal read FWNDHandle;
  end;

  TForm2 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
  FMyThread :TMyThread;
    { Private-Deklarationen }
  public

  Fmsg:TMessage;
    { Public-Deklarationen }
  end;

var
  Form2: TForm2;

implementation

{$R *.dfm}
constructor TMyThread.Create(CreateSuspended: Boolean);
begin
  inherited Create(CreateSuspended);
  FWNDHandle := AllocateHWnd(WndProc);
end;

constructor TMyThread.Create;
begin
  inherited Create;
  FWNDHandle := AllocateHWnd(WndProc);
end;
destructor TMyThread.Destroy;
begin
  DeallocateHWnd(FWNDHandle);
  inherited;
end;

procedure TMyThread.Execute;
begin


  while not Terminated do
  begin
    Sleep(10);
  end;


end;

procedure TMyThread.WndProc(var Msg: TMessage);
begin
  OutputDebugString(PWideChar('TMyThread.WndProc - Msg: #' + IntToStr(Msg.Msg) + '-'+  IntToStr(Msg.WParam)));
end;

procedure TForm2.Button1Click(Sender: TObject);
begin
  FMyThread := TMyThread.Create(false);
end;

procedure TForm2.Button2Click(Sender: TObject);

begin
  Fmsg.Msg := 12345;
  FMsg.WParam := 2345;
  SendMessage(FMyThread.GetWNDHandle,FMsg.Msg,FMsg.WParam,FMsg.LParam);
end;

end.

[DeddyH]

Wenn man nicht aufpasst, kann SendMessage zu einem Deadlock führen, ich würde lieber PostMessage verwenden.