#Persistent
WS := new WatchSizing()

class WatchSizing
{
	__New()  {
		static EVENT_SYSTEM_MOVESIZESTART := 0xA, EVENT_SYSTEM_MOVESIZEEND := 0xB
			, EVENT_OBJECT_LOCATIONCHANGE := 0x800B, array := {}
		array.i := 0
		this.ptr := Object(array)
		this.hHookSizing := this.SetWinEventHook(EVENT_SYSTEM_MOVESIZESTART, EVENT_SYSTEM_MOVESIZEEND, 0
															, RegisterCallback("HookProcSizing", "F", 4, this.ptr), 0, 0, 0)
		this.hHookMoving := this.SetWinEventHook(EVENT_OBJECT_LOCATIONCHANGE, EVENT_OBJECT_LOCATIONCHANGE, 0
															, RegisterCallback("HookProcMoving", "F", 4, this.ptr), 0, 0, 0)
		this.hHookMaximising := this.SetWinEventHook(EVENT_OBJECT_LOCATIONCHANGE, EVENT_OBJECT_LOCATIONCHANGE, 0
															, RegisterCallback("HookProcMaximising", "F", 4), 0, 0, 0)
	}
	
	__Delete()  {
		DllCall("UnhookWinEvent", Ptr, this.hHookSizing)
		DllCall("UnhookWinEvent", Ptr, this.hHookMoving)
		DllCall("UnhookWinEvent", Ptr, this.hHookMaximising)
		ObjRelease(this.ptr)
	}
	
	SetWinEventHook(eventMin, eventMax, hmodWinEventProc, lpfnWinEventProc, idProcess, idThread, dwFlags)  {
		return DllCall("SetWinEventHook", UInt, eventMin , UInt, eventMax , Ptr, hmodWinEventProc
					, Ptr, lpfnWinEventProc , UInt, idProcess , UInt, idThread, UInt, dwFlags, Ptr)
	}
}

HookProcSizing(hWinEventHook, event, hwnd, idObject)
{
	static EVENT_SYSTEM_MOVESIZESTART := 0xA, EVENT_SYSTEM_MOVESIZEEND := 0xB, OBJID_WINDOW := 0, obj
	if (idObject != OBJID_WINDOW)
		Return
	
	(!obj && obj := Object(A_EventInfo))
	(event = EVENT_SYSTEM_MOVESIZESTART && (obj.watching := 1, obj.hwnd := hwnd))
	(event = EVENT_SYSTEM_MOVESIZEEND && (obj.watching := "", obj.i := 0))
}

HookProcMoving(hWinEventHook, event, hwnd, idObject)
{
	static OBJID_WINDOW := 0, W_Prev, H_Prev, obj
	(!obj && obj := Object(A_EventInfo))
	if !(idObject = OBJID_WINDOW && obj.watching && hwnd = obj.hwnd)
		Return
	
	if (obj.i++ = 0)
		WinGetPos,,, W_Prev, H_Prev, ahk_id %hwnd%
	if (obj.i = 2)  {
		WinGetPos,,, W, H, ahk_id %hwnd%
		if !(W = W_Prev && H = H_Prev)
			SetTimer, AlertSizing, -10
	}
}

HookProcMaximising(hWinEventHook, event, hwnd, idObject)
{
	static OBJID_WINDOW := 0, arr := [], FuncObj := Func("AlertMaximizing").Bind(arr)
	if (idObject != OBJID_WINDOW)
		Return
	arr[1] := hwnd
	SetTimer, % FuncObj, -100
}

AlertSizing()
{
	ToolTip Sizing!
	SoundBeep, 500
}

AlertMaximizing(obj)
{
	static arr := []
	hwnd := obj[1]
	WinGet, MinMax, MinMax, ahk_id %hwnd%
	if (MinMax = 1 && !arr.HasKey(hwnd))  {
		arr[hwnd] := 1
		ToolTip Maximized
		SoundBeep, 1000
	}
	if (MinMax != 1 && arr.HasKey(hwnd))
		arr.Delete(hwnd)
}

Это так, сходу, наверное, можно ещё оптимизировать.

Ну, можно в его HookProc Sleep вставить.

А что это даст?

Ну, можно в его HookProc Sleep вставить. На самом деле, совместив EVENT_SYSTEM_MOVESIZESTART и EVENT_OBJECT_LOCATIONCHANGE, скорее всего, можно достоверно получать начало изменения размера окна. Ну, и для отслеживания максимизации что-то придумать можно. Сейчас пока занят, попозже могу написать.

Можно отслеживать EVENT_SYSTEM_MOVESIZESTART, далее по таймеру определять размер окна вплоть до EVENT_SYSTEM_MOVESIZEEND.
Максимизация — отслеживать EVENT_OBJECT_LOCATIONCHANGE и по таймеру проверять, не максимизировано ли.

Не подходит, надо определять одномоментно.

EVENT_OBJECT_LOCATIONCHANGE сильно грузит процесс и часто вешает его если есть какие то действия в обработчике. Приходит очень много сообщений, и даже если при каждом выставлять короткий таймер, то из за частоты сообщений он может не скоро запустится.

Вариант с GetKeyState("LButton", "P") или A_Cursor не рассматриваю.