How to pass a method as callback to a Windows API call?

Question

I\'d like to pass a method of a class as callback to a WinAPI function. Is this possible and if yes, how?

Example case for setting a timer:

TMyClass          


        

Answer 1

Response to your second edit:

If you want a reply that includes a pointer to a TMyClass instance, you may be out of luck. Fundamentally, the procedure Windows will call has a certain signature and is not an object method. You cannot directly work around that, not even with __closure or procedure of object magic, except as described below and in other answers. Why?

• Windows has no knowledge of it being an object method, and wants to call a procedure with a specific signature.

• The pointer is no longer a simple pointer - it has two halves, the object instance and the method. It needs to save the Self, as well as the method.

By the way, I don't understand what is wrong with a short dip outside the object-oriented world. Non-OO code is not necessarily dirty if used well.

Original, pre-your-edit answer:

It's not possible exactly as you are trying to do it. The method that SetTimer wants must exactly follow the TIMERPROC signature - see the MSDN documentation. This is a simple, non-object procedure.

However, the method TMyClass.DoIt is an object method. It actually has two parts: the object on which it is called, and the method itself. In Delphi, this is a "procedure of object" or a "closure" (read about procedural types here). So, the signatures are not compatible, and you cannot store the object instance, which you need in order to call an object method. (There are also calling convention problems - standard Delphi methods are implemented using the fastcall convention, whereas TIMERPROC specifies CALLBACK which, from memory, is a macro that expands to stdcall. Read more about calling conventions and especially fastcall.)

So, what do you do? You need to map your non-object-oriented callback into object-oriented code.

There are several ways, and the simplest is this:

If you only have one timer ever, then you know that when your timer callback is called it is that specific timer that fired. Save a method pointer in a variable that is of type procedure of object with the appropriate signature. See the Embarcadero documentation link above for more details. It will probably look like:

type TMyObjectProc = procedure of object;
var pfMyProc : TMyObjectProc;

Then, initialise pfMyProc to nil. In TMyClass.DoIt, set pfMyProc to @DoIt - that is, it is now pointing at the DoIt procedure in the context of that specific TMyClass instantiation. Your callback can then call that method.

(If you're interested, class variables that are of a procedural type like this are how event handlers are stored internally. The OnFoo properties of a VCL object are pointers to object procedures.)

Unfortunately this procedural architecture is not object-oriented, but it's how it has to be done.

Here's what some full code might look like (I'm not at a compiler, so it may not work as written, but it should be close):

type TMyObjectProc = procedure of object;
var pfMyProc : TMyObjectProc;

initialization
  pfMyProc = nil;

procedure MyTimerCallback(hWnd : HWND; uMsg : DWORD; idEvent : PDWORD; dwTime : DWORD); stdcall;
begin
  if Assigned(pfMyProc) then begin
    pfMyProc(); // Calls DoIt, for the object that set the timer
    pfMyProc = nil;
  end;
end;

procedure TMyClass.MyOOCallback;
begin
  // Handle your callback here
end;

procedure TMyClass.DoIt;
begin
  pfMyProc = @MyOOCallback;
  SetTimer(0, 0, 8, @ MyTimerCallback);
end;

Another way would be to take advantage of the fact your timer has a unique ID. Save a mapping between the timer ID and the the object. In the callback, convert from the ID to the pointer, and call the object's method.

Edit: I've noticed a comment to another answer suggesting using the address of your object as the timer ID. This will work, but is a potentially dangerous hack if you end up having two objects at the same address at different times, and you don't call KillTimer. I've used that method but don't personally like it - I think the extra bookkeeping of keeping a (timer ID, object pointer) map is better. It really comes down to personal style, though.