Nutzung einer Callback-Funktion innerhalb eines Objekts

[Niko]

Ich möchte in einem Objekt eine Callback-Funktion benutzen. Das Problem dabei ist, dass sich Methoden nicht als Callback-Funktion übergeben lassen.

Die einzige Möglichkeit, die ich kenne, sieht folgendermaßen aus und erscheint mir recht umständlich:
Verwendung einer normalen Prozedur als Callback-Funktion. Diese Funktion sendet eine (benutzerdefinierte) Message, die widerum von einem unsichtbaren Fenster des Objekts verarbeitet wird.

Weiß jemand eine andere Methode, um das Problem zu lösen?

[Chewie]

Ein ähnliches Problem hatte ich auch mal: http://www.delphipraxis.net/internal...ect.php?t=7339

[negaH]

Wie sieht die Callback aus und was kann man der Aufruffunktion an zusätzlichen Parametern übergeben ?

Ideal wäre

Delphi-Quellcode:

type
  TCallback = function(UserData: Pointer; .....): ....; stdcall;

procedure EnumXYZ(..., UserData: Pointer; Callback: TCallback);

D.h. die besten Callbacks benutzen als 1. Parameter in der Callback einen Benutzerdefinierten Zeiger/Integer etc. Dann ist es einfach diesen als Self vom Object zu benutzen, sprich so:

Delphi-Quellcode:

type
  TMyObject = class
    funtcion Callback(.....): ....; stdcall; 
  end;

Als UserData wird Self übergeben, und die Callback Methode lässt diesen einfach weg.

Gruß Hagen

[DaFox]

Hi!

Zitat von Niko:

Ich möchte in einem Objekt eine Callback-Funktion benutzen.

Hast Du den hidden parameter (Referenz auf die Instanz der Klasse [Self]) berücksichtigt?

Gruß,
Markus

// Edit: Sorry, Hagen. "Wer lesen kann ist klar im Vorteil!" Ich war mal wieder schneller mit dem Schreiben als mit dem Lesen.

[Niko]

Erstmal Danke für die Antworten und die Gratulation (siehe Signatur Chewie)

@Chewie:
Wie ich das ganze mit einer Message machen könnte, weiß ich (mir würde AllocateHWnd zum Erzeugen eines unsichtbaren Fensters mit Nachrichtenschleife reichen). Ich hatte aber gehofft, auf den Umweg mit der Message verzichten zu können.

@negaH:
Ja, es lässt sich ein benutzerdefinierter Integer übergeben. Allerdings verstehe ich noch nicht, was mir die Übergabe von self an UserData bringen soll...

Mein Problem besteht darin, dass ich an die Aufruffunktion nicht einfach mit @Methode die Adresse meiner Callback-Methode übergeben kann. Der konkrete Fall:

Ich habe eine Callback-Funktion folgenden Typs:
TFSoundStreamCallback = function (Stream: PFSoundStream; Buff: Pointer; Length, Param: Integer): ByteBool; cdecl; Die Aufruffunktion sieht folgendermaßen aus:
function FSound_Stream_SetEndCallback(Stream: Pointer; Callback: TFSoundStreamCallback; UserData: Integer): Integer; In meinem Objekt gibt es eine Methode "EndCallback" vom Typ TFSoundStreamCallback, die bei jedem Callback aufgerufen werden soll. Dazu müsste ich diese Methode als Callback an
TFSound_Stream_SetEndCallback übergeben:
FSound_Stream_SetEndCallback(FStreamHandle, EndCallback, 0); Und genau das ist nicht möglich, sondern liefert mir die Fehlermeldung
"Inkompatible Typen: Reguläre Prozedur und Methodenzeiger".

[negaH]

So in der TFSoundStreamCallback ist der UserParam als letzter Parameter und das ist ein Problem. Aber erst mal eine kleine Einführung was Proceduren von Methoden unterscheidet, dann wird einiges klarer für dich.

Eine Procedure/Funktion hat meisten Parameter, also z.b. so:

procedure XYZ(Parameter: Pointer); Schön, eine Methode ist eine Procedure die einer Objectinstance oder Klasse zugeordnet wurde, mehr nicht. Damit man aber innerhalb dieser Procedure auch auf die Eigenschaften/Felder usw. des Objectes/Klasse zugreifen kann wird jeder Methode ein unsichtbarer Parameter Self mit übergeben. Also so:

Delphi-Quellcode:

type
  TMyObject = class
    procedure XYZ(Paramter: Pointer);
  end;

in Wirklichkeit sieht die Methode XYZ aber so aus:

procedure TMyObject_XYZ(Self: TMyObject; Paramter: Pointer); So angenommen eine clever deklariete Callback sähe so aus:

Delphi-Quellcode:

type
  TFSoundStreamCallback = function (Param: Integer; Stream: PFSoundStream; Buff: Pointer; Length: Integer): ByteBool; cdecl;

D.h. statt Param=unser Benutzer definitierbarer Wert, am Ende steht er am Anfang !

Somit wäre eine solche Callback sofort kompatibel zu einer Onject methode indem wir als UserParam eben das Object selber übergeben, also so:

Delphi-Quellcode:

type
  TMyObject = class
    function Callback(Stream: PFSoundStream; Buff: Pointer; Length: Integer): Integer; cdecl;
  end;

und mit folgendem Code rufen wir dann auf:

Delphi-Quellcode:

var
  MyObject: TMyObject;
begin
  MyObject := TMyObject.Create;
  FSound_Stream_SetEndCallback(FStreamHandle, @TMyObject.Callback, MyObject);
end;

Somit könnten wir ohne Probleme direkt unsere Object Methode (nicht vieruell oder dynamische methode) direkt benutzen.

Da aber hier C/C++ Coder am werkeln waren haben sie leider den Userparam Param ans Ende der Parameterliste gesetzt, also müssen wirs so machen:

Delphi-Quellcode:

type
  TMyObject = class
    function Callback(Stream: PFSoundStream; Buff: Pointer; Length: Integer): Integer;
  end;

function Callback(Stream: PFSoundStream; Buff: Pointer; Length: Integer; Param: TMyObject): Integer; cdecl
begin
  Result := Param.Callback(Stream, Buff, Length);
end;

var
  MyObject: TMyObject;
begin
  MyObject := TMyObject.Create;
  FSound_Stream_SetEndCallback(FStreamHandle, @Callback, MyObject);
end;

Andererseits ist der Vorteil bei der Sache das nun wiederum TMyObject Callback eine andere Aufrufkonventio, hier register, und Parameterreihenfolge benutzen kann. Zudem kann jetzt TMyObject.Callback() auch als virtual oder dynamic deklariert sein.

Gruß Hagen

[Niko]

Danke, genau so etwas habe ich gesucht... und nebenbei wieder etwas über den internen Aufbau von Methode gelernt!