TWndMethod = procedure(var Message: TMessage) of object;
...
function AllocateHWnd(Method: TWndMethod): HWND;
var
  TempClass: TWndClass;
  ClassRegistered: Boolean;
begin
  UtilWindowClass.hInstance := HInstance;
{$IFDEF PIC}
  UtilWindowClass.lpfnWndProc := @DefWindowProc;
{$ENDIF}
  ClassRegistered := GetClassInfo(HInstance, UtilWindowClass.lpszClassName,
    TempClass);
  if not ClassRegistered or (TempClass.lpfnWndProc <> @DefWindowProc) then
  begin
    if ClassRegistered then
      Windows.UnregisterClass(UtilWindowClass.lpszClassName, HInstance);
    Windows.RegisterClass(UtilWindowClass);
  end;
  Result := CreateWindowEx(WS_EX_TOOLWINDOW, UtilWindowClass.lpszClassName,
    '', WS_POPUP {+ 0}, 0, 0, 0, 0, 0, 0, HInstance, nil);
  if Assigned(Method) then
    SetWindowLong(Result, GWL_WNDPROC, Longint(MakeObjectInstance(Method)));
end;

function MakeObjectInstance(Method: TWndMethod): Pointer;
const
  BlockCode: array[1..2] of Byte = (
    $59,       { POP ECX }
    $E9);      { JMP StdWndProc }
  PageSize = 4096;
var
  Block: PInstanceBlock;
  Instance: PObjectInstance;
begin
  if InstFreeList = nil then
  begin
    Block := VirtualAlloc(nil, PageSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    Block^.Next := InstBlockList;
    Move(BlockCode, Block^.Code, SizeOf(BlockCode));
    Block^.WndProcPtr := Pointer(CalcJmpOffset(@Block^.Code[2], @StdWndProc));
    Instance := @Block^.Instances;
    repeat
      Instance^.Code := $E8;  { CALL NEAR PTR Offset }
      Instance^.Offset := CalcJmpOffset(Instance, @Block^.Code);
      Instance^.Next := InstFreeList;
      InstFreeList := Instance;
      Inc(Longint(Instance), SizeOf(TObjectInstance));
    until Longint(Instance) - Longint(Block) >= SizeOf(TInstanceBlock);
    InstBlockList := Block;
  end;
  Result := InstFreeList;
  Instance := InstFreeList;
  InstFreeList := Instance^.Next;
  Instance^.Method := Method;
end;

{ Free an object instance }

procedure FreeObjectInstance(ObjectInstance: Pointer);
begin
  if ObjectInstance <> nil then
  begin
    PObjectInstance(ObjectInstance)^.Next := InstFreeList;
    InstFreeList := ObjectInstance;
  end;
end;

#pragma once
#include <Windows.h>
#include <map>
#include <functional>

using msg_proc = std::function<void(UINT msg, WPARAM&, LPARAM&)>; // Обработчик события Windows

class stealth_window
{
public:

	stealth_window();
	virtual ~stealth_window();

	void add_msg(UINT msg, msg_proc proc);
	HWND handle = nullptr; // Хэндл невидимого окна

protected:
	virtual void wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
private:
	std::multimap<UINT, msg_proc> msg_procs;
	tagWNDCLASSA uwc{ 0, WndProc,0, 0, 0, 0, 0, 0, 0, "TPUtilWindow" };
	static LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
};

#include "stealth_window.h"
stealth_window::stealth_window()
{
	const HMODULE hinstance = GetModuleHandleA(nullptr);
	tagWNDCLASSA tmp_class;
	this->uwc.hInstance = hinstance;
	const auto registered = GetClassInfoA(hinstance, uwc.lpszClassName, &tmp_class);

	if (!registered || (tmp_class.lpfnWndProc != DefWindowProcA)) {
		if (registered)
			UnregisterClassA(uwc.lpszClassName, hinstance);
		RegisterClassA(&uwc);
	}

	handle = CreateWindowExA(WS_EX_TOOLWINDOW, uwc.lpszClassName, "",
		WS_POPUP, 0, 0, 0, 0, 0, 0, hinstance, this);
}


stealth_window::~stealth_window()
{
	if (handle) {
		DestroyWindow(handle);
		handle = nullptr;
	}
}

void stealth_window::add_msg(UINT msg, msg_proc proc)
{
	msg_procs.insert({ msg, std::move(proc) });
}

void stealth_window::wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{ // Обработка сообщений. Сообщение с одинаковым кодом может иметь несколько обработчиков. 
	auto& it = msg_procs.lower_bound(msg);
	const auto& upper_bound = msg_procs.upper_bound(msg);
	while (it != upper_bound)
		(it++)->second(msg, wParam, lParam);
}


LRESULT stealth_window::WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	stealth_window* realThis;

	if (msg == WM_NCCREATE) // Первое сообщение - при создании окна. В lParam приходит this
	{
		realThis = static_cast<stealth_window*>(reinterpret_cast<CREATESTRUCT*>(lParam)->lpCreateParams);

		SetLastError(0);
		if (!SetWindowLongPtr(hwnd, GWL_USERDATA, reinterpret_cast<LONG_PTR>(realThis)))
			if (GetLastError())
				return FALSE;
	}
	else
		realThis = reinterpret_cast<stealth_window*>(GetWindowLongPtr(hwnd, GWL_USERDATA));

	if (realThis)
		realThis->wnd_proc(hwnd, msg, wParam, lParam);

	return DefWindowProcA(hwnd, msg, wParam, lParam);
}