const
  fbclient = 'fbclient.dll';

function isc_attach_database(status_vector            : PISC_STATUS;
                               db_name_length           : Short;
                               db_name                  : PByte;
                               db_handle                : PISC_DB_HANDLE;
                               parm_buffer_length	  : Short;
                               parm_buffer              : PByte): ISC_STATUS; stdcall; external fbclient;
function isc_detach_database(status_vector: PISC_STATUS; db_handle : PISC_DB_HANDLE): ISC_STATUS; stdcall; external fbclient;
function isc_print_status(AStatus: PISC_STATUS): ISC_STATUS; stdcall; external fbclient;
function isc_event_block(var EventBuffer : PByte; var ResultBuffer: PByte; IDCount: UShort;
  Event1, Event2, Event3, Event4, Event5, Event6, Event7, Event8, Event9,
  Event10, Event11, Event12, Event13, Event14, Event15: PByte): ISC_LONG; cdecl; external fbclient;
function isc_que_events(
       status_vector             : PISC_STATUS;
       db_handle                 : PISC_DB_HANDLE;
       event_id                  : PISC_LONG;
       length                    : Short;
       event_buffer              : PByte;
       event_function            : TISC_CALLBACK;
       event_function_arg        : PVoid): ISC_STATUS; stdcall; external fbclient;
procedure isc_event_counts(
       status_vector             : PUISC_LONG;
       buffer_length             : Short;
       event_buffer              : PByte;
       result_buffer             : PByte); stdcall; external fbclient;
function isc_cancel_events(status_vector            : PISC_STATUS;
                               db_handle                : PISC_DB_HANDLE;
                               event_id                 : PISC_LONG): ISC_STATUS; stdcall; external fbclient;

threadvar
  status_vector: array[0..19] of ISC_STATUS;

function AddDPBVal(var ADPB: PByte; AValue: Byte): PByte; overload;
begin
  ADPB^ := AValue;
  Inc(ADPB);
  Result := ADPB;
end;

function AddDPBVal(var ADPB: PByte; AName: Byte; AValue: PAnsiChar): PByte; overload;
var
  LLen: Byte;
begin
  AddDPBVal(ADPB, AName);
  LLen := StrLen(AValue);
  AddDPBVal(ADPB, LLen);
  Move(AValue^, ADPB^, LLen);
  Inc(ADPB, LLen);
  Result := ADPB;
end;

function AddDPBVal(var ADPB: PByte; AName, AValue: Byte): PByte; overload;
begin
  AddDPBVal(ADPB, AName);
  AddDPBVal(ADPB, 1);
  AddDPBVal(ADPB, AValue);
  Result := ADPB;
end;

function IsFBError: Boolean;
begin
  Result := (status_vector[0] = 1) and (status_vector[1] <> 0);
end;

function CheckFBSuccess: Boolean;
begin
  if IsFBError then begin
    isc_print_status(@status_vector);
    Result := False;
  end else
    Result := True;
end;

function ConnectToDB(AName: PAnsiChar): TISC_DB_HANDLE;
var
  LDPBBuf: array[Byte] of Byte;
  LDPB: PByte;
  LDPBLength: SmallInt;
begin
  LDPB := @LDPBBuf[0];
  AddDPBVal(LDPB, isc_dpb_version1);

  AddDPBVal(LDPB, isc_dpb_user_name, 'SYSDBA');
  AddDPBVal(LDPB, isc_dpb_password, 'masterkey');

  LDPBLength := NativeUInt(LDPB) - NativeUInt(@LDPBBuf[0]);
  Result := nil;

  isc_attach_database(@status_vector[0], StrLen(AName), PByte(AName), @Result, LDPBLength, @LDPBBuf[0]);
  if IsFBError then
    Result := nil;
end;

type
  TEventData = record
    Event: PByte;
    Result: PByte;
    hEvent: THandle;
  end;
  PEventData = ^TEventData;

procedure EventCallback(AData: Pointer; ALength: Word; AUpdated: PByte); cdecl;
var
  LData: PEventData;
begin
  if (ALength = 0) or (AUpdated = nil) then
    Exit;
  LData := AData;
  Move(AUpdated^, LData^.Result^, ALength);
  isc_event_counts(@status_vector[0], ALength, LData^.Event, LData^.Result);
  if LData^.hEvent <> 0 then begin
    SetEvent(LData^.hEvent);
    Exit;
  end;
  if status_vector[0] <> 0 then
    MessageBox(0, 'Event', '', 0);
end;

function WaitEvent(ADB: TISC_DB_HANDLE; const AEvents: array of PAnsiChar): ISC_LONG;
var
  LData: PEventData;
  LLen: SmallInt;
  LEvents: array of PByte;
begin
  LData := VirtualAlloc(nil, SizeOf(LData^), MEM_COMMIT, PAGE_READWRITE);
  LLen := Length(AEvents);
  SetLength(LEvents, LLen);
  Move(AEvents[0], LEvents[0], LLen * SizeOf(AEvents[0]));
  LLen := isc_event_block(LData^.Event, LData^.Result, Length(AEvents),
    LEvents[0], LEvents[1], LEvents[2], LEvents[3], LEvents[4], LEvents[5],
    LEvents[6], LEvents[7], LEvents[8], LEvents[9], LEvents[10], LEvents[11],
    LEvents[12], LEvents[13], LEvents[14]
  );
  LData^.hEvent := CreateEvent(nil, False, False, nil);
  isc_que_events(@status_vector[0], @ADB, @Result, LLen, LData^.event, @EventCallback, PVoid(LData));
  if not CheckFBSuccess then
    Exit(0);
  WaitForSingleObject(LData^.hEvent, INFINITE);
  CloseHandle(LData^.hEvent);
  LData^.hEvent := 0;
  isc_que_events(@status_vector[0], @ADB, @Result, LLen, LData^.event, @EventCallback, PVoid(LData));
  if not CheckFBSuccess then
    Result := 0;
end;

const
  CEventNames: array[0..7] of AnsiString = (
    'EVENT_UPD_SUBS',
    'EVENT_POSTS_AU',
    'EVENT_POSTS_AU_NEW',
    'EVENT_PLAN_REPORT',
    'EVENT_TSK_COMMAND',
    'INS_REGISTRATION_EVENT',
    'EVENT_QUEUE_CFG',
    'EVENT_QUEUE_DELTA_CFG'
  );

procedure TestApi;
var
  LDB: TISC_DB_HANDLE;
  LEvent: ISC_LONG;
  Li: Integer;
  LData: array[0..Length(CEventNames) - 1] of PAnsiChar;
begin
  LDB := ConnectToDB('xnet://D:\DB\Temp.fdb');
  if not CheckFBSuccess then
    Exit;
  for Li := 0 to Length(CEventNames) - 1 do
    LData[Li] := PAnsiChar(CEventNames[Li]);
  LEvent := WaitEvent(LDB, LData);
  Sleep(1000);
  isc_cancel_events(@status_vector[0], @LDB, @LEvent);
  isc_detach_database(@status_vector[0], @LDB);
end;

program Project1;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils,
  Unit4 in 'Unit4.pas';

begin
  try
    TestApi;
  except
    on E: Exception do
      Writeln(E.Message);
  end;
  Write('Press <ENTER>...');
  Readln;
end.

function WaitEvent(ADB: TISC_DB_HANDLE; const AEvents: array of PAnsiChar): ISC_LONG;
var
  LData: PEventData;
  LLen: SmallInt;
  LEvents: array of PByte;
begin
  LData := VirtualAlloc(nil, SizeOf(LData^), MEM_COMMIT, PAGE_READWRITE);
  LLen := Length(AEvents);
  if LLen > 15 then
    LLen := 15;
  SetLength(LEvents, 15);
  FillChar(LEvents[0], Length(LEvents) * SizeOf(AEvents[0]), 0);
  Move(AEvents[0], LEvents[0], LLen * SizeOf(AEvents[0]));
  LLen := isc_event_block(LData^.Event, LData^.Result, Length(AEvents),
    LEvents[0], LEvents[1], LEvents[2], LEvents[3], LEvents[4], LEvents[5],
    LEvents[6], LEvents[7], LEvents[8], LEvents[9], LEvents[10], LEvents[11],
    LEvents[12], LEvents[13], LEvents[14]
  );
  Writeln('Before isc_wait_for_event');
  isc_wait_for_event(@status_vector[0], @ADB, LLen, LData^.event, LData^.Result);
  Writeln('After isc_wait_for_event');
  if not CheckFBSuccess then
    Result := 0;
  isc_event_counts(@status_vector[0], LLen, LData^.Event, LData^.Result);
  isc_que_events(@status_vector[0], @ADB, @Result, LLen, LData^.event, @EventCallback, PVoid(LData));
  if not CheckFBSuccess then
    Result := 0;
end;