Question

I am developing application which intend to be cross platform. I used to use Windows Messages but now I am dropping it out. I replaced messages with callbacks but regardless I can use different technologies I am not aware of different possibilites when not using windows messages.

Well I have main exe aplication and some dll plugins. I have some objects and threads in dll and I would like to notify main application about some changes that DLL made to data structure.

As I said I am currently working with some callbacks. To provide compatibility with different languages (C++, VB, C#) I have non-object type of callback. I am not sure if other languages supports callback of object.

So my questions are:

• What are the alternatives (cross-platform) to windows messages? Can callbacks replace messages?
• Do other languages support callback of object?
• I guess other languages have different technologies as alternative to messages?

Answer 1

So my questions are:
What are the alternatives (cross-platform) to windows messages? Can callbacks replace messages?

Yes you can replace messages with callbacks.

Do other languages support callback of object?

You shouldn’t use object methods as callbacks. Common practice in portable code is use of handles (notify calling convention):

DLL source:

type
  THandle = LongWord;
  {$IF SizeOf(THandle) < SizeOf(Pointer))}
  {$MESSAGE Error 'Invallid handle type'}
  {$ENDIF}

  TCallback = procedure(const aHandle: THandle); cdecl;

  var
      gCallback: record
        Routine: TCallback;
        Obj: TObject;
        Info: string
  end;

  function Object2Handle(const aObj: TObject): THandle;
  begin
    Result:= THandle(Pointer(aObj))
  end;

  function Handle2Object(const aHandle: THandle; out aObj: TObject): Boolean;
  begin
    if gCallback.Obj <> nil then
      if aHandle = Object2Handle(gCallback.Obj) then
      begin
        aObj:= gCallback.Obj;
        Result:= true;
        Exit // WARRNING: program flow disorder
      end;

    aObj:= nil;
    Result:= false
  end;

procedure DoCallback();
begin
  if Assigned(gCallback.Routine) then
    gCallback.Routine(Object2Handle(gCallback.Obj))
end;

procedure SetupCallback(const aCallback: TCallback); cdecl;
begin
  gCallback.Routine:= aCallback;
end;

procedure DoSomething(const aHandle: THandle; out aInfo: string); cdecl;
var
  O: TObject;
begin
  if Handle2Object(aHandle, O) then
    aInfo:= Format('%s class object %s', [O.ClassName(), gCallback.Info])
end;

procedure Test();
begin
  gCallback.Obj:= TStream.Create();
  try
    gCallback.Info:= 'created';
    DoCallback();
  finally
    FreeAndNil(gCallback.Obj)
  end;
  gCallback.Obj:= TMemoryStream.Create();
  try
    gCallback.Info:= 'will be freed';
    DoCallback();
  finally
    FreeAndNil(gCallback.Obj)
  end
end;

exports
  SetupCallback,
  DoSomething,
  Test;

Executable source:

procedure Cb(const aHandle: THandle); cdecl;
const
  STUPID: THandle = 1;
  EQUALLY_STUPID = $DEAD;
var
  S: string;
begin
  DoSomething(STUPID, S);
  DoSomething(aHandle, S);
  DoSomething(EQUALLY_STUPID, S)
end;

begin
  SetupCallback(@Cb);
  Test()
end.

Edited: You can’t shoot yourself in you leg now.

I guess other languages have different technologies as alternative to messages?

OS have a few message alternatives. However not many truly portable.

You can also use:

• sockets,
• (IMO too big in this case?) ready messaging system (my favorite 0MQ)