Wo ist hier der (Denk-)Fehler? Aufruf von EnumWindowsProc

[ustra]

Hi,

ich habe es mir angesehen. Ich sage nur: Wer lesen kann, ist klar im Vorteil. Sorry, da war ich zu schnell. Ich habe es übersehen, dass Du die Definition der Methode geändert hast. Dann kann es theoretisch laufen. Kompiliere ich nun das, meldet mir der Compiler:

Variable erforderlich in der Zeile:EnumWindows(@EnumWindowsProc, Integer(Self)); Beste Grüße
Ulrich

[neolithos]

Das ist schnell gelöst

EnumWindows(@TWaechter.EnumWindowsProc, Integer(Self));

[Luckie]

Nimm dein Enum WindowsProc aus der Klasse raus und mach es so:

Delphi-Quellcode:

type
  PMyEnumParam = ^TMyEnumParam;
  TMyEnumParam = record
    lb: TListbox;
  end;

function GetWindows(const hWnd: Longword; Param: PMyEnumParam): LongBool;
  stdcall;
var
  Len: Longint;
  S: string;
begin
  Result := True;
  if not (IsWindow(hWnd) and IsWindowVisible(hWnd)) then
    Exit;
  Len := SendMessage(hWnd, WM_GETTEXTLENGTH, 0, 0);
  if Len > 0 then
  begin
    SetLength(S, Len);
    SendMessage(hWnd, WM_GETTEXT, Len + 1, Longint(Pchar(S)));
    Param.lb.Items.Add(s);
  end;
  // mit Result = False kann die Callbackfunktion vorzeitig verlassen werden
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  Param: TMyEnumParam;
begin
  Param.lb := Listbox1;
  EnumWindows(@GetWindows, LPARAM(@Param));
end;

Wenn du es in der Klasse drin hast, wird automatisch der unsichtbare Self-Parameter mitgeführt von Delphi und dann passt die Deklaration nicht mehr wie sie eiegntlich von Windows sein müsste.

[ustra]

Hi alle miteinander,

erstmal Danke für Eure Bemühungen. Ich habe dank Eurer Hilfe das Problem gelöst. Nun noch mal im Detail:

@Neolithos: Ich habe es so gemacht, wie angegeben. Allerdings stürzt das Programm dann komplett ab. Irgendeine Zugriffsverletzung. Wo genau der Fehler ist, kann ich Dir nicht sagen.

@Luckie: Ich habe jetzt Deine Methode ausprobiert und tatsächlich, das funktioniert.

Noch mal, recht herzlichen Dank. Ihr seid eine richtig KLASSE Forum. Die Seite ist auch meine Startseite, weil Sie mir so gut gefällt. Ein dickes Lob an Euch.

Ulrich

[neolithos]

Ich dachte bei class-Sachen gibt es keine Instanz.

Lieg ich da ein bißchen falsch. Wenn Ja!

Dann:

Delphi-Quellcode:

function WaechterEWProc(hWindow : DWORD; fWaechter : TWaechter) : Longbool; 
...
begin
..
end;

EnumWindows(@WaechterEWProc, Integer(Self));

Das mit der Struktur kann man sich sparen.

[stoxx]

Hallo Ustra,

falls Du es doch noch schön objectorientiert machen möchtest, und somit auch auf alle Methoden des Objectes zugreifen kannst. Hier nochmal die Lösung

viele Grüße
stoxx

Code:

unit Unit2;

interface

type Tmyclass = class;

    private
        enumpointer : Pointer;
        function EnumWinProc(WinHandle: HWND; lParam: LPARAM): boolean; StdCall;
    public

        constructor create; virtual;
        destructor destroy; override;
        procedure aufruf;

    end; // von Tmyclass

implementation



function MakeProcInstance(M: TMethod): Pointer; 
begin
  // allocate memory
  GetMem(Result, 15);
  asm
    // MOV ECX,
    MOV BYTE PTR [EAX], $B9
    MOV ECX, M.Data
    MOV DWORD PTR [EAX+$1], ECX
    // POP EDX
    MOV BYTE PTR [EAX+$5], $5A
    // PUSH ECX
    MOV BYTE PTR [EAX+$6], $51 
    // PUSH EDX
    MOV BYTE PTR [EAX+$7], $52
    // MOV ECX,
    MOV BYTE PTR [EAX+$8], $B9 
    MOV ECX, M.Code
    MOV DWORD PTR [EAX+$9], ECX
    // JMP ECX
    MOV BYTE PTR [EAX+$D], $FF
    MOV BYTE PTR [EAX+$E], $E1
  end;
end;

//////////////////////////////////////////////////////////////////////////////////

procedure FreeProcInstance(ProcInstance: Pointer);
begin
  // free memory
  FreeMem(ProcInstance, 15);
end;

//////////////////////////////////////////////////////////////////////////////////

constructor Tmyclass.create;
var t : Tmethod;
begin
inherited create;
 t.Code := @Tmyclass.enumwinproc;
 t.Data := self;
 enumpointer := makeProcInstance(t);
end;    // von create

//////////////////////////////////////////////////////////////////////////////////

destructor Tmyclass.destroy;
begin
 FreeProcInstance(enumPointer); // aufräumen
 inherited destroy;
end;  /// von free

//////////////////////////////////////////////////////////////////////////////////


function Tmyclass.EnumWinProc(WinHandle: HWND; lParam: LPARAM): boolean; StdCall;
begin

  ... Code

end;    // von enumwindowsprocedure




//////////////////////////////////////////////////////////////////////////////////

  // Aufruf  //
procedure Tmyclass.aufruf;
begin
 EnumWindows(enumpointer,0);
end;

end.

[Chewie]

Zitat von neolithos:

Ich dachte bei class-Sachen gibt es keine Instanz.

Lieg ich da ein bißchen falsch. Wenn Ja!

Na ja, man kann in einer Klassenmethode auch auf andere Klassenmethoden zugreifen. D.h., zumindest einen Zeiger auf die Klasse muss es schon geben.

[ustra]

Hi,

@stoxx: ich habe es nicht mehr ausprobiert, aber ich denke, dass würde laufen. Luckies variante ist auch gut. Wenn ich das nächste Mal vor dem Problem stehe, werde ich noch mal Deine Lösung ausprobieren. Vielleicht mache ich das noch. Trotzdem danke für Deine Bemühungen.

Beste Grüße
Ulrich