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.

[Bummi]

@DeddyH
:thumb: hatte der TE eh drin, ist mir beim Debuggen passiert und übersehen worden

[Viktorii]

Hmmm... Wird so das Fenster nicht im Kontext des Hauptthreads erzeugt?

Das Fenster wird im Constructor des TThread Objekts erzeugt. Und der Constructor läuft ja im Kontext des Hauptthreads, oder?

Somit würde doch sowohl das neue Fenster als auch die WndProc im Haupthread laufen, auch wenn die WndProc zum TThread gehört?

Oder habe ich da jetzt einen Denkfehler?


Wie kann ich das verifizieren?

Im TThread Objekt kann ich das mit

Delphi-Quellcode:

OutputDebugString(PWideChar('ThreadID: ' + IntToStr(Self.ThreadID)));

machen, weil ThreadID eine Eigenschaft von TThread ist.

Wie kann ich die ThreadID in einer Methode von TForm abgeleiteten Objekts herausbekommen?

[DeddyH]

Das ist ein MessageOnly-Window, das nicht an irgendwelche Steuerelemente gebunden ist. Es läuft somit auch nicht im Kontext des MainThreads. Und was meinst Du mit der 2. Frage? Du kannst doch auf ThreadInstanz.ThreadId (lesend) zugreifen, oder meinst Du etwas anderes?

[himitsu]

Wenn man Messages in einem Thread empfangen will, dann muß das Window auch innerhalb des Threads erzeugt werden, da PostMessage und Co. die Nachrichten an die Nachrichtenschleife des Threads sendet, welcher mit dem Wiondows verbunden ist.
Auch SendMessage wird dann innerhalb des entsprechenden Threads ausgeführt.

Also sollen die Messages im Thread ankommen und verarbeitet werden, dann muß das Windows auch im Thread erstellt werden.
Ansonsten kann man auch gleich das Handle seiner Form oder von Applivation verwenden.

Falls ihr noch etwas Zeit habt, dann kann ich nach der Arbeit mal eine Message-Thread-Klasse hochladen. (hab da was rumliegen)

[sirius]

@visktorii

Deine whileschleife ist falsch.

Die sollte so lauten:

Delphi-Quellcode:

while getmessage(msg,0,0,0) do dispathcmessage(msg);

Dann musst du noch die Methode Terminate verdekcen und darin Postquitmessage(0);Postthreadmessage(... wm_Quit ...); dazufügen.

[Viktorii]

Zu meiner zweiten Frage: Ich habe sowas hier gesucht: http://msdn.microsoft.com/en-us/libr...(v=vs.85).aspx


Nun habe ich mir mal anzeigen lassen, was in welchem Thread läuft:

Delphi-Quellcode:

Debug-Ausgabe: TFormMain.WndProc - ThreadID: 32408 Prozess reDesign.exe (24708)
Debug-Ausgabe: TFormMain.WndProc - ThreadID: 32408 Prozess reDesign.exe (24708)
Debug-Ausgabe: TFormMain.WndProc - ThreadID: 32408 Prozess reDesign.exe (24708)
Debug-Ausgabe: TMyThread.Create - ThreadID: 32408 Prozess reDesign.exe (24708)
Debug-Ausgabe: TFormMain.Create - ThreadID: 32408 Prozess reDesign.exe (24708)
Debug-Ausgabe: TMyThread.Execute - ThreadID: 23024 Prozess reDesign.exe (24708)
Debug-Ausgabe: TMyThread.WndProc - ThreadID: 32408 Prozess reDesign.exe (24708)
Debug-Ausgabe: TFormMain.WndProc - ThreadID: 32408 Prozess reDesign.exe (24708)
Debug-Ausgabe: TMyThread.WndProc - ThreadID: 32408 Prozess reDesign.exe (24708)
Debug-Ausgabe: TFormMain.WndProc - ThreadID: 32408 Prozess reDesign.exe (24708)

Und wie ich hier glaube zu sehen läuft die WndProc von TThread im Thread 32408 was der Hauptthread wäre und nicht im neu erzeugten Thread mit der ID 23024 (siehe TMyThread.Execute).

Oder interpretiere ich hier irgendwas falsch?


Edit: Oh die Beiträge von himitsu uns sirius hatte ich noch nicht gesehen... aber die Frage bleibt :)

[DeddyH]

Du hast ja 2 WndProcs, einmal im MainThread und einmal im TestThread. Nimm die im MainThread doch einmal raus.

[Bummi]

Am schnellsten bekommst Du es wenn Du mal 2 Threads startest und deren ThreadIds mit ausgeben lässt...

[himitsu]

So, bevor ich's wieder vergeß...

Hab den Code auch mal mit ein paar Debuginfos versehn. (siehe Ereignisprotokoll Strg+Alt+V)

[edit]
Für D2010 und älter müßte man die zweite Threadklasse entfernen, welche mit in der Unit rumliegt.