frame: extend attribute click dispatcher (one-verb-per-click, spell/macro/menu)

The `type*` click path now mirrors retail's SecureActionButton_OnClick:
resolve ONE verb per click from the modifier/button-qualified `type`
attribute and perform it, instead of a fixed `type1=target`.

- Modifier/button resolution: `[alt-/ctrl-/shift-]type[1..5]` with
  prefix..name..suffix -> name..suffix -> name precedence, read from the
  live key state and the click's button.
- Verbs: target (with the engine's default-interaction precedence -
  cast a pending spell / drop a cursor item on the unit instead of
  switching target), assist, focus, spell, stopcasting, macro, and menu.
- Own-the-click: when a verb resolves we perform it and do NOT chain the
  frame's previous OnClick, so a configured `type1` no longer double-
  dispatches alongside an addon's own conditional click handler.
- Self-healing wire: addons that re-SetScript OnClick (pfUI on every raid
  relayout) clobber our closure; WireOnClick re-wraps a clobbered Lua
  handler but skips its own C closure, so re-setting `type*` recovers
  without double-chaining.

Dispatch goes straight to C++ where we own the code - no Lua round-trip
through the global table: spell -> Spell::AtUnit::CastByName (a native
unit-targeted cast; the unit's GUID is fed to the engine's dispatcher so
there's no target juggling, and ground-target spells land at the unit's
feet), focus -> Unit::Focus::Set, and the target verb's predicates ->
Spell::AtCursor::IsPlacementActive / Cursor::Info::HasItem. Only genuine
engine entries (TargetUnit/AssistUnit/SpellTargetUnit/DropItemOnUnit/
SpellStopCasting) and addon-provided functions still go through Lua
globals. Spell::AtUnit gains a C++ header sharing its CastCore with the
C_Spell.CastAtUnit Lua entry.

macro verb: takes the content from the `macrotext`/`macro` attribute and
prefers an addon-provided RunMacro (SuperCleveRoidMacros etc. - handles
named macros and extended macro text), falling back to running the text
natively when no RunMacro global is present. The native path runs each
line through the stock FrameXML ChatEdit_ParseText via a throwaway
edit-box (GetText closure + no-op __index), so it needs no addon.

menu/togglemenu verb: pops the standard unit dropdown at the cursor via
the new ClassicAPI_ToggleUnitMenu (Util/SecureUnitMenu.lua), resolving
the unit -> menu type with Blizzard's own generic resolver
(self->SELF, pet->PET, grouped player->PARTY, other player->PLAYER,
NPC->RAID_TARGET_ICON). Keeps the FrameXML dropdown logic in Lua with
the C side as a thin call.

Author: brues-code

AddOns/!!!ClassicAPI/!!!ClassicAPI.toc

@@ -44,3 +44,4 @@ Util\Vector3D.lua
 Util\Vector4D.lua
 Util\UIParent.lua
 Util\AuraDurationModifiers.lua
+Util\SecureUnitMenu.lua

AddOns/!!!ClassicAPI/Util/SecureUnitMenu.lua

@@ -0,0 +1,59 @@
+-- Unit right-click menu for attribute-driven unit frames.
+--
+-- Backs the `menu` / `togglemenu` click verb of the Frame:SetAttribute
+-- backport (see src/frame/Attributes.cpp). When a frame with a `unit`
+-- attribute resolves a click to the `menu` verb, the DLL calls
+-- ClassicAPI_ToggleUnitMenu(unit), which pops the standard unit dropdown at
+-- the cursor -- the same UnitPopup menu Blizzard's PlayerFrame / TargetFrame /
+-- PartyMemberFrame show on right-click. Lets a unit frame express its
+-- right-click menu purely as an attribute (e.g. type2 = "menu") instead of a
+-- hand-rolled OnClick handler.
+--
+-- The unit -> menu-type resolution mirrors Blizzard's own generic resolver
+-- (TargetFrameDropDown_Initialize in FrameXML): self -> SELF, pet -> PET, a
+-- grouped player -> PARTY (whisper / inspect / trade / follow / promote / ...),
+-- any other player -> PLAYER (adds INVITE), anything else (NPC) ->
+-- RAID_TARGET_ICON. Vanilla's stock UI never wires a unit to the "RAID" menu
+-- (there are no clickable raid unit frames in 1.12), and PARTY carries the
+-- options players actually want on a grouped member, so grouped players (party
+-- or raid) use PARTY -- matching how pfUI drives its raid menu.
+
+local dropdown;
+
+local function EnsureDropdown()
+    if not dropdown then
+        dropdown = CreateFrame("Frame", "ClassicAPIUnitMenuDropDown", UIParent, "UIDropDownMenuTemplate");
+        dropdown.displayMode = "MENU";
+    end
+    return dropdown;
+end
+
+local function ResolveMenu(unit)
+    if UnitIsUnit(unit, "player") then
+        return "SELF";
+    elseif UnitIsUnit(unit, "pet") then
+        return "PET";
+    elseif UnitIsPlayer(unit) then
+        if UnitInParty(unit) or UnitInRaid(unit) then
+            return "PARTY";
+        end
+        return "PLAYER";
+    end
+    return "RAID_TARGET_ICON";
+end
+
+function ClassicAPI_ToggleUnitMenu(unit)
+    if not unit or not UnitExists(unit) then
+        return;
+    end
+    local which = ResolveMenu(unit);
+    local name;
+    if which == "RAID_TARGET_ICON" then
+        name = RAID_TARGET_ICON;
+    end
+    local dd = EnsureDropdown();
+    dd.initialize = function()
+        UnitPopup_ShowMenu(dd, which, unit, name);
+    end
+    ToggleDropDownMenu(1, nil, dd, "cursor");
+end

docs/API.md

@@ -3844,25 +3844,53 @@ may be any token the resolver understands — `"party1"`, `"target"`, `"focus"`,
 `"nameplateN"`, or a raw GUID literal. Set `unit` to a non-string (e.g. `nil`)
 to stop the binding.
 
-**Click actions (`type1` / `type2`).** A `type` attribute makes clicking the
-frame act on its `unit`:
-
-```lua
-f:SetAttribute("type1", "target")   -- left-click targets the unit
-f:SetAttribute("type2", "focus")    -- right-click sets ClassicAPI focus to it
-```
-
-Left-click reads `type1`, right-click reads `type2`, and both fall back to a
-plain `type` attribute. Supported verbs: `"target"`, `"assist"` (target the
-unit's target), `"focus"`. Setting a `type*` attribute installs a **chained
-`OnClick` on that frame only** (nothing global) — it reads the attributes at
-click time and runs *after* any handler the frame already had. Because it chains
-whatever `OnClick` is present when the `type` attribute is set, set `type*`
-**after** the frame's own scripts (real addons configure attributes after
-building the widget). The frame must be a **Button** registered for the click:
-left is the Button default; right needs `RegisterForClicks("RightButtonUp")`,
-which real unit frames already call. Other verbs (`togglemenu`, `spell`,
-`macro`) aren't backported yet.
+**Click actions (`type1` / `type2` / …).** A `type` attribute makes clicking the
+frame perform one action on its `unit` — the retail secure-button model: exactly
+**one verb per click**, resolved from the attributes.
+
+```lua
+f:SetAttribute("type1", "target")        -- left-click targets the unit
+f:SetAttribute("type2", "focus")         -- right-click sets ClassicAPI focus to it
+-- click-casting, expressed purely as attributes:
+f:SetAttribute("shift-type1", "spell")
+f:SetAttribute("shift-spell1", "Flash Heal")   -- shift-left-click heals the unit
+```
+
+**Resolution.** The verb is read from `[prefix]type[suffix]`, where the prefix is
+the held modifiers (`alt-`, `ctrl-`, `shift-`, in that order) and the suffix is
+the button number (`1`=Left, `2`=Right, `3`=Middle, `4`/`5`=side). Precedence is
+`prefix..type..suffix` → `type..suffix` → `type`, so `type1` applies under any
+modifier unless a modifier-specific attribute (`shift-type1`) overrides it — and
+`type` (no suffix) is the catch-all.
+
+**Verbs:** `target`, `assist`, `focus`, `spell` (reads the modifier-qualified
+`spell` attribute and casts it on the unit via the native
+[`C_Spell.CastAtUnit`](#c_spellcastatunitspellidorname-unit) — the unit's GUID is fed straight to
+the cast dispatcher, so there's no target juggling, and ground-target spells
+land at the unit's feet), `macro` (takes the
+`macrotext`/`macro` attribute and prefers an addon-provided `RunMacro` — e.g.
+SuperCleveRoidMacros, which handles named macros and extended macro text —
+falling back to running the text natively, line by line through the stock
+`ChatEdit_ParseText`, when no `RunMacro` global is present), `stopcasting`, and `menu` /
+`togglemenu` (pops the standard unit dropdown — whisper/inspect/trade/invite/…,
+the same menu `PlayerFrame`/`TargetFrame`/`PartyMemberFrame` show — at the
+cursor). `target` respects the engine's default-interaction precedence: with a
+spell on the cursor it casts on the unit, with an item on the cursor it drops it
+on the unit, instead of switching target.
+
+**One verb per click.** Setting a `type*` attribute installs a **chained
+`OnClick` on that frame only** (nothing global). When a verb resolves, our
+handler *owns* the click and does **not** run the frame's previous `OnClick` —
+so a configured `type1` never fires alongside the addon's own click handler.
+Unconfigured clicks (no matching `type`, or an unrecognized verb) fall through
+to the frame's own `OnClick`, so an addon can keep custom behavior there. The
+frame must be a **Button** registered for the click
+(left is the Button default; right needs `RegisterForClicks("RightButtonUp")`).
+
+**Clobbering.** The handler self-heals: addons that re-`SetScript("OnClick", …)`
+(pfUI on every raid relayout) replace our closure, so re-set a `type*` attribute
+afterward to reinstall — re-wiring detects and skips its own closure, so it never
+double-chains.
 
 **`OnAttributeChanged` is not fired.** Retail fires this script from
 `SetAttribute` (and `SetAttributeNoHandler` suppresses it). Making it a real