Windowprocs umleiten

[DGL-luke]

Frage geklärt, Thread umgestaltet

Da man öfters mal auf messages reagieren möchte, auf die einem die Komponente keinen Zugriff (z.B. durch Events) gewährt, ist es sehr nützlich, wenn man weiss, wie man eine Windowproc - also die Botschaftsschleife - umbiegt bzw. wrappt. So kann man übrigens auch gezielt Nachrichten vor einem Steuerelement verbergen.

Das geht ganz einfach:

Delphi-Quellcode:

FOldWndProc := FTargetControl.WindowProc;
FTargetControl.WindowProc := InternalWndProc;

FOldWndProc muss eine Variable vom Typ TWndProc sein. Auf diese wird nun die ursprüngliche Wndproc geschoben und der "freie Platz" dann mit InternalWndproc, eine Prozedur die implementiert sein muss, belegt.(Vorsicht, der vorangehende Satz ist technisch nicht ganz korrekt!)

Diese sollte dann in etwa so aussehen:

Delphi-Quellcode:

procedure TForm1.InternalWndProc(var Msg: TMessage);
begin
if Msg.Message = WM_SOME_SPECIAL_MESSAGE then //Message raussuchen
 handlespecialmessage(Msg)                    //Message behandlen
else OldWndProc(Msg);                         //alle anderen Messages werden an das Control weitergegeben
end;

Cool, oder?

Dankeschön an Flocke, der diese Möglichkeit und zwei weitere weiter unten sehr gut erklärt! (Ich möchte auch nicht den Eindruck aufkommen lassen, ich hätte das selbst gemacht - ich habe nur Flockes erste Möglichkeit ein wenig beschrieben!)

Hier nochmal die ursprüngliche Frage:


kann ich die Wndproc eines TTreeview überschreiben?

Delphi-Quellcode:

 OldTVWndProc:=@TVDataBase.windowproc;
 TVDataBase.windowproc := TVWndProc;

Das funktioniert zwar, aber der aufruf von OldWndProc bringt nur AVs. ist das, weil ich es durch die zuweisung aus seinem Klassenkontext reisse?

Geht so etwas anders, ohne eine neue treeview-klasse abzuleiten?

Eigentlich will ich ja nur dateien auf die treeview droppen können - geht das auch einfacher?

[SirThornberry]

lass mal das "@weg".
ist "TVDataBase" eigentlich die Klasse oder schon die Instanz? Wenn es die Klasse ist dann ganz schnell hilfe anschauen denn bei dem Thema musst du die Instanz verwenden.

[DGL-luke]

nein, keine angst. wie bereits gesagt, will ich ja nicht von TTreeview ableiten also ist TVDatabase ein TTreeview.

und das @weglassen geht nicht, dann heissts

Zitat:

[Fehler] Mangaview_Main.pas(116): E2009 Inkompatible Typen: 'Reguläre Prozedur und Methodenzeiger'

ps: danke daniel!

[Flocke]

Wenn du die Eigenschaft WindowProc benutzt, dann muss es keine Windows-Fensterprozedur sein sondern eine TWndMethod, also etwa:

Delphi-Quellcode:

FOldWndProc := FTargetControl.WindowProc;
FTargetControl.WindowProc := InternalWndProc;

und mit dem Prototyp

procedure TNewClass.InternalWndProc(var Msg: TMessage); [Nachtrag]

Ansonsten musst du die Fensterprozedur mit SetWindowLong/GWL_WNDPROC setzen. Dann kannst du auch eine normale Windows WNDPROC nehmen.

[DGL-luke]

es geht!

na das ist aber ne ganz schöne redundanz, die du da hast... ein einfaches "dein oldwndproc muss von typ TWndProc sein" hätte gereicht. jetzt hab ich mindestens ne minute zum durchsteigen gebraucht...

aber danke!

[Flocke]

Zitat von DGL-luke:

na das ist aber ne ganz schöne redundanz, die du da hast... ein einfaches "dein oldwndproc muss von typ TWndProc sein" hätte gereicht. jetzt hab ich mindestens ne minute zum durchsteigen gebraucht...

Sorry für die verlorene Minute hab die Zeilen einfach aus einem meiner Files kopiert und nicht großartig angepasst

[Nachtrag]

Noch einmal ausführlicher: Du hast drei Varianten für das Subclassing.

Variante 1 benutzt die Eigenschaft WindowProc, die jedes TWinControl hat. Dies ist in meinen Augen die beste Variante, da sie auch funktioniert wenn sich zwischendurch das Fensterhandle sich ändert.

Delphi-Quellcode:

type
  TfrmTest = class(TForm)
    TVDataBase: TTreeView;
    procedure FormCreate(Sender: TObject);
  private
    OldTVWndProc: TWndMethod;
    procedure TVWndProc(var Msg: TMessage);
  end;

var
  frmTest: TfrmTest;

procedure TfrmTest.TVWndProc(var Msg: TMessage);
begin
  // Deine Implementierung
  // ...
  // dann:
  OldTVWndProc(Msg);
end;

procedure TfrmTest.FormCreate(Sender: TObject);
begin
  OldTVWndProc := TVDataBase.WindowProc;
  TVDataBase.WindowProc := TVWndProc;
  // sonstiger Code
end;

Variante 2 benutzt direkt die Fensterprozedur zusammen mit einer Windows WNDPROC. Das hat den Nachteil, dass du aus TVWndProc nur über Umwege (z.B. eine globale Variable) an die Daten des Formulars kommst. Außerdem ist das Subclassing weg wenn das Fensterhandle neu erzeugt wird.

Delphi-Quellcode:

type
  TfrmTest = class(TForm)
    TVDataBase: TTreeView;
    procedure FormCreate(Sender: TObject);
  private
    OldTVWndProc: FarProc;
  end;

var
  frmTest: TfrmTest;

function TVWndProc(hWnd: HWND; uMsg: UINT; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall;
begin
  // Deine Implementierung
  // ...
  // dann:
  Result := CallWindowProc(OldTVWndProc, uMsg, wParam, lParam);
end;

procedure TfrmTest.FormCreate(Sender: TObject);
begin
  OldTVWndProc := Pointer(GetWindowLong(TVDataBase.Handle, GWL_WNDPROC));
  SetWindowLong(TVDataBase.Handle, GWL_WNDPROC, LongInt(@TVWndProc));
  // sonstiger Code
end;

Variante 3 benutzt TWndMethod zusammen mit SetWindowLong/GWL_WNDPROC. Hat auch den Nachteil, dass das Subclassing weg ist wenn das Fensterhandle neu erzeugt wird.

Delphi-Quellcode:

type
  TfrmTest = class(TForm)
    TVDataBase: TTreeView;
    procedure FormCreate(Sender: TObject);
  private
    NewTVWndProc: FARPROC;
    OldTVWndProc: FARPROC;
    procedure TVWndProc(var Msg: TMessage);
  end;

var
  frmTest: TfrmTest;

procedure TfrmTest.TVWndProc(var Msg: TMessage);
begin
  // Deine Implementierung
  // ...
  // dann:
  Msg.Result := CallWindowProc(OldTVWndProc, TTreeView.Handle, Msg.Msg. Msg.wParam, Msg.lParam);
end;

procedure TfrmTest.FormCreate(Sender: TObject);
begin
  NewTVWndProc := MakeObjectInstance(TVWndProc);
  OldTVWndProc := Pointer(GetWindowLong(TVDataBase.Handle, GWL_WNDPROC));
  SetWindowLong(TVDataBase.Handle, GWL_WNDPROC, LongInt(NewTVWndProc));
  // sonstiger Code
end;

procedure TfrmTest.FormDestroy(Sender: TObject);
begin
  SetWindowLong(TVDataBase.Handle, GWL_WNDPROC, LongInt(OldTVWndProc));
  FreeObjectInstance(NewTVWndProc);
  // sonstiger Code
end;

[DGL-luke]

jo, flocke, hab die erste möglichkeit jetzt nach oben geschoben. Danke noch mal!