Unerlaubte Member-Variablen im Service?

[Phoenix]

Hier die Lösung:
(was lange währt wird endilch gut heisst es doch? ;-) )

Delphi-Quellcode:

// constructor
//
constructor PhService.Create;
var
   t: TMethod;
begin
   t.Code := @PhService.serviceproc;
   t.Data := self;
   m_serviceProcInst := MakeProcInstance(t);  // m_serviceProcInst ist ein normaler Pointer, der an die API übergeben wird
end;

// destructor
//
destructor PhService.Destroy;
begin
   FreeProcInstance(m_serviceProcInst); // aufräumen
   inherited;
end;

[stoxx]

@ Phoenix & Motzi

ich stand gerade vor dem gleichen Problem. Und diese Lösung funktioniert perfekt !
Es war gut Phoenix, dass Du die Lösung noch gepostet hast, hätte ich auf die Schnelle nicht herausgefunden.

Dagegen ist diese Lösung regelrecht umständlich:
http://www.delphipraxis.net/internal...ht=enumwindows

[Luckie]

Ich habe jetzt mal versucht das mit der API-Funktion EnumWindows umzusetzen:

Delphi-Quellcode:

program Project2;

{$APPTYPE CONSOLE}

uses
  Windows;

type
  TEnumWindows = class(TObject)
  private
    EnumProcInst: Pointer;
    function MakeProcInstance(M: TMethod): Pointer;
    procedure FreeProcInstance(ProcInstance: Pointer);
    function EnumWindows(hWnd: THandle; lp: LPARAM): Boolean; stdcall;
  public
    constructor Create;
    destructor Destroy; override;
  end;

{ TEnumWindows }

function TEnumWindows.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 TEnumWindows.FreeProcInstance(ProcInstance: Pointer);
begin
  // free memory
  FreeMem(ProcInstance, 15);
end;

constructor TEnumWindows.Create;
var
  Method: TMethod;
begin
  Method.Code := @TEnumWindows.EnumWindows;
  Method.Data := Self;
  EnumProcInst := MakeProcInstance(Method);
  EnumWindows(Cardinal(EnumProcInst), 0);
end;

function TEnumWindows.EnumWindows(hWnd: THandle; lp: LPARAM): Boolean; stdcall;
begin
  Writeln(hWnd);
  Result := True;
end;


destructor TEnumWindows.Destroy;
begin
  FreeProcInstance(EnumProcInst);
  inherited;
end;

var
  EnumWnds: TEnumWindows;

begin
  EnumWnds := TEnumWindows.Create;
  EnumWnds.Free;
  Readln;
end.

Das scheint leider nicht ganz zu funktionieren, da ich nur ein Handle ausgegeben bekomme.

[Phoenix]

Im Moment machst Du ja noch nichts mit der Klasse als solches. Probier mal, die EnumWIndowsProc direkt zu übergeben und schau ob Du dann mehrfach aufgerufen wirst. Es könnte sein, dass der ASM-Block den Rückgabewert nicht wieder an Windows zurück durchreicht - was Du aber brauchst..

[Luckie]

Ich rufe es doch im Konstruktor auf.

Zitat:

Zitat von Phoenix

Probier mal, die EnumWIndowsProc direkt zu übergeben und schau ob Du dann mehrfach aufgerufen wirst. Es könnte sein, dass der ASM-Block den Rückgabewert nicht wieder an Windows zurück durchreicht - was Du aber brauchst..

Wie meinst du das?

[SirThornberry]

@Luckie: Warum so kompliziert? nutze doch den lParam um die ObjectInstanz zu übergeben wenn du den lparam sowieso nicht nutzt. Und selbst wenn du den lparam nutzten willst kannst du dort auch einen Pointer auf einen Record übergeben der deinen eigentlichen lparam enthält und zustäzlich die Instanz.

Variante wenn lParam nicht benötigt wird

Delphi-Quellcode:

function GlobalEnumWindows(hWnd: THandle; lp: LPARAM): Boolean; stdcall; 
begin
  TEnumWindows(lp).EnumWindows(hWnd, 0);
end;

constructor TEnumWindows.Create; 
begin 
  Windows.EnumWindows(@GlobalEnumWindows, Cardinal(Self)); 
end; 

function TEnumWindows.EnumWindows(hWnd: THandle): Boolean; stdcall; 
begin 
  Writeln(hWnd); 
  Result := True; 
end;

Der Fehler bei dir lag daran das du im Create zwar "EnumWindows" aufrufst, aber da EnumWindows eine Methode deiner Klasse ist wird diese aufgerufen und nicht die EnumWindows-Funktion aus der Unit Windows
Anstelle von:

Delphi-Quellcode:

constructor TEnumWindows.Create; 
var 
  Method: TMethod; 
begin 
  Method.Code := @TEnumWindows.EnumWindows; 
  Method.Data := Self; 
  EnumProcInst := MakeProcInstance(Method); 
  EnumWindows(Cardinal(EnumProcInst), 0); 
end;

müsste es also mindestens so aussehen:

Delphi-Quellcode:

constructor TEnumWindows.Create; 
var 
  Method: TMethod; 
begin 
  Method.Code := @TEnumWindows.EnumWindows; 
  Method.Data := Self; 
  EnumProcInst := MakeProcInstance(Method); 
  windows.EnumWindows(EnumProcInst, 0); 
end;

ansonsten wird wie bereits erwähnt deine Methode aufgerufen und der erste Parameter ist dann nicht ein Handle sondern "Cardinal(EnumProcInst)".

[Luckie]

:wall: :wall: :wall:

Ich habe es jetzt so:

Delphi-Quellcode:

type
  TEnumWindows = class(TObject)
  private
    EnumProcInst: Pointer;
    function MakeProcInstance(M: TMethod): Pointer;
    procedure FreeProcInstance(ProcInstance: Pointer);
    function EnumWindows(hWnd: THandle; lp: LPARAM): Boolean; stdcall;
  public
    constructor Create;
    destructor Destroy; override;
  end;

{ TEnumWindows }

function TEnumWindows.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 TEnumWindows.FreeProcInstance(ProcInstance: Pointer);
begin
  // free memory
  FreeMem(ProcInstance, 15);
end;

constructor TEnumWindows.Create;
var
  Method: TMethod;
begin
  Method.Code := @TEnumWindows.EnumWindows;
  Method.Data := Self;
  EnumProcInst := MakeProcInstance(Method);
  Windows.EnumWindows(EnumProcInst, 0);
end;

function TEnumWindows.EnumWindows(hWnd: THandle; lp: LPARAM): Boolean; stdcall;
var
  Buffer: PChar;
  len: Integer;
begin
  if IsWindow(hWnd) and IsWindowVisible(hWnd) then
  begin
    len := SendMessage(hWnd, WM_GETTEXTLENGTH, 0, 0);
    if len > 0 then
    begin
      Buffer := GetMemory(len + 1);
      try
        SendMessage(hWnd, WM_GETTEXT, len, Integer(Buffer));
        Writeln(Buffer);
      finally
        FreeMemory(Buffer);
      end;
    end;
  end;
  Result := True;
end;

destructor TEnumWindows.Destroy;
begin
  FreeProcInstance(EnumProcInst);
  inherited;
end;

Aber irgendwas stimmt mit dem Speicher nicht. Entweder sind die Fenstertitel abgeschnitten oder es hängt noch Zeichensalat hinten dran. Aber die Routine hab eich schon tausendmal so geschrieben. Muss ich da noch was beachten, wenn die Callback eine Methode einer Klasse ist?

[SirThornberry]

mach mal aus

Delphi-Quellcode:

SendMessage(hWnd, WM_GETTEXT, len, Integer(Buffer));

einfach

Delphi-Quellcode:

SendMessage(hWnd, WM_GETTEXT, len + 1, Integer(Buffer));

ansonsten fehlt dir die abschließende #0
Oder initialisiere den speicher vorher mit #0
[Edit]Tippfehler beseitigt[/Edit]

[Luckie]

:wall: :wall: :wall:

Das ist heute nicht mein Tag. Ich gehe jetzt erstmal in eine Besprechung. Mal sehen, was ich da für einen Mist verzapfen kann. :?