engine.lua

--[[--------------------------------------------------------------------------
  Clickcast - engine.lua

  Unit resolution, frame hooking and the actual click handler.

  The click handler mirrors pfUI's pfUI.uf:ClickAction() with one deliberate
  difference: when no click action is configured for the pressed
  button+modifier combination, the frame's *original* OnClick script is run
  instead. That keeps every existing unit frame behaving exactly as it did
  before Clickcast was installed, and only overrides the clicks you bind.
----------------------------------------------------------------------------]]

local CC = Clickcast

CC.hooked   = {}   -- [frame] = true
CC.oldclick = {}   -- [frame] = original OnClick script (may be nil)
CC.hasmouse = {}   -- [frame] = true if the frame handles its own mouse events

-- buttons the original OnClick script is allowed to receive. Clickcast widens
-- every hooked frame to five buttons; frames were usually only registered for
-- left/right, so unbound extra buttons must stay silent instead of leaking
-- into a handler that never expected them.
local passthrough_buttons = {
  ["LeftButton"]  = true,
  ["RightButton"] = true,
}

-- ---------------------------------------------------------------------------
-- unit strings
-- ---------------------------------------------------------------------------
local staticunits = {
  ["player"]               = "player",
  ["pet"]                  = "pet",
  ["pettarget"]            = "pettarget",
  ["target"]               = "target",
  ["targettarget"]         = "targettarget",
  ["targettargettarget"]   = "tttarget",
  ["focus"]                = "focus",
  ["focustarget"]          = "focustarget",
  ["mouseover"]            = "other",
}

function CC:IsValidUnit(unit)
  if not unit or unit == "" or type(unit) ~= "string" then return nil end
  if staticunits[unit] then return true end
  if string.find(unit, "^party[1-4]$") then return true end
  if string.find(unit, "^partypet[1-4]$") then return true end
  if string.find(unit, "^party[1-4]target$") then return true end
  if string.find(unit, "^raid%d+$") then return true end
  if string.find(unit, "^raidpet%d+$") then return true end
  if string.find(unit, "^raid%d+target$") then return true end
  return nil
end

function CC:GetCategory(unit)
  if not unit then return "other" end
  if staticunits[unit] then return staticunits[unit] end
  if string.find(unit, "^partypet%d") then return "partypet" end
  if string.find(unit, "^party%d+target$") then return "partytarget" end
  if string.find(unit, "^party%d") then return "party" end
  if string.find(unit, "^raidpet%d") then return "raidpet" end
  if string.find(unit, "^raid%d+target$") then return "raidtarget" end
  if string.find(unit, "^raid%d") then return "raid" end
  return "other"
end

-- Blizzard's raid frames don't expose a unit id we can rely on, so the player
-- name shown on the button is matched against the raid roster instead.
local function ResolveRaidButton(frame)
  if not frame.GetName then return nil end
  local name = frame:GetName()
  if not name then return nil end
  if not string.find(name, "^RaidGroupButton%d+$")
    and not string.find(name, "^RaidPullout%d+Button%d+$") then return nil end

  local label = getglobal(name .. "Name")
  local player = label and label.GetText and label:GetText()
  if not player or player == "" then return nil end

  for i = 1, GetNumRaidMembers() do
    if UnitName("raid" .. i) == player then return "raid" .. i end
  end
  return nil
end

-- Works out which unit a frame represents. Supports the conventions used by
-- pfUI (label/id), Blizzard and most third party frames (unit / unitid), and
-- explicit registrations through Clickcast:Register(frame, unit).
function CC:GetUnit(frame)
  if not frame then return nil end

  local unit

  if type(frame.ccUnit) == "string" then
    unit = frame.ccUnit
  end

  -- pfUI style: frame.label .. frame.id
  if not unit and type(frame.label) == "string" and frame.label ~= "" then
    unit = frame.label .. (type(frame.id) == "string" and frame.id or "")
  end

  if not unit and type(frame.unit) == "string" then unit = frame.unit end
  if not unit and type(frame.unitid) == "string" then unit = frame.unitid end
  if not unit and type(frame.unitId) == "string" then unit = frame.unitId end
  if not unit and type(frame.unitstr) == "string" then unit = frame.unitstr end

  if not unit and frame.GetAttribute then
    local ok, value = pcall(frame.GetAttribute, frame, "unit")
    if ok and type(value) == "string" then unit = value end
  end

  if not unit then unit = ResolveRaidButton(frame) end

  if unit then unit = string.lower(unit) end
  if CC:IsValidUnit(unit) then return unit end
  return nil
end

-- ---------------------------------------------------------------------------
-- action lookup
-- ---------------------------------------------------------------------------
-- pfUI builds its modifier string as alt -> ctrl -> shift and only ever stores
-- single-modifier entries, so holding two modifiers resolves to nothing and
-- falls through. That behaviour is reproduced here.
function CC:GetModifier()
  local modstring = ""
  if IsAltKeyDown() then modstring = modstring .. "alt" end
  if IsControlKeyDown() then modstring = modstring .. "ctrl" end
  if IsShiftKeyDown() then modstring = modstring .. "shift" end
  return modstring
end

function CC:GetAction(button)
  local bid = CC.buttonid[button or ""]
  if not bid then return nil end
  local action = CC.db.actions[CC:ActionKey(bid, CC:GetModifier())]
  if not action or action == "" then return nil end
  return action
end

-- ---------------------------------------------------------------------------
-- dropdown menus (pfUI.uf:RightClickAction, generalised to any unit string)
-- ---------------------------------------------------------------------------
function CC:ShowMenu(unit)
  if unit == "player" then
    ToggleDropDownMenu(1, nil, PlayerFrameDropDown, "cursor")
    return
  elseif unit == "target" then
    ToggleDropDownMenu(1, nil, TargetFrameDropDown, "cursor")
    return
  elseif unit == "pet" then
    ToggleDropDownMenu(1, nil, PetFrameDropDown, "cursor")
    return
  end

  local _, _, partyid = string.find(unit, "^party([1-4])$")
  if partyid then
    local dropdown = getglobal("PartyMemberFrame" .. partyid .. "DropDown")
    if dropdown then
      ToggleDropDownMenu(1, nil, dropdown, "cursor")
      return
    end
  end

  -- everything else goes through the generic unit popup
  if not UnitExists(unit) then return end
  local name = UnitName(unit)
  FriendsDropDown.displayMode = "MENU"
  FriendsDropDown.initialize = function()
    UnitPopup_ShowMenu(getglobal(UIDROPDOWNMENU_OPEN_MENU), "PARTY", unit, name)
  end
  ToggleDropDownMenu(1, nil, FriendsDropDown, "cursor")
end

-- ---------------------------------------------------------------------------
-- casting (pfUI.uf:ClickAction, cast branch)
-- ---------------------------------------------------------------------------
function CC:Cast(action, unit)
  local is_macro = string.find(action, "^%/(.+)")

  if CC:UseSuperWoW() and not is_macro then
    -- SuperWoW can cast directly at a unit, no target juggling required
    CastSpellByName(action, unit)
    return
  end

  local tswitch = UnitIsUnit(unit, "target")
  TargetUnit(unit)

  if is_macro then
    RunMacroText(action)
  else
    CastSpellByName(action)
  end

  if not tswitch then TargetLastTarget() end
end

-- ---------------------------------------------------------------------------
-- click handling
-- ---------------------------------------------------------------------------

-- what a frame did before Clickcast hooked it. Used for unbound clicks, and as
-- a stand-in default for frames that never had an OnClick script at all.
function CC:Passthrough(frame, button, unit)
  local original = CC.oldclick[frame]
  if original then
    if passthrough_buttons[button or ""] then original() end
    return
  end

  -- the frame drives itself through OnMouseDown/OnMouseUp, which still fire on
  -- their own - stepping in here would double up on whatever it already does
  if CC.hasmouse[frame] then return end

  if not unit then return end

  if SpellIsTargeting() then
    if button == "RightButton" then SpellStopTargeting() return end
    if button == "LeftButton" then SpellTargetUnit(unit) return end
  end

  if CursorHasItem() then
    DropItemOnUnit(unit)
    return
  end

  if button == "RightButton" then
    CC:ShowMenu(unit)
    return
  end

  TargetUnit(unit)
end

function CC:OnClick(frame, button)
  button = button or "LeftButton"

  local unit = CC:GetUnit(frame)

  if CC.db.enabled ~= "1" or not unit then
    return CC:Passthrough(frame, button, unit)
  end

  if CC.db.units[CC:GetCategory(unit)] ~= "1" then
    return CC:Passthrough(frame, button, unit)
  end

  local action = CC:GetAction(button)
  if not action then
    return CC:Passthrough(frame, button, unit)
  end

  -- a bound click still has to respect a pending spell cursor or a held item,
  -- exactly like pfUI does before it looks at the click action
  if SpellIsTargeting() then
    if button == "RightButton" then SpellStopTargeting() return end
    if button == "LeftButton" then SpellTargetUnit(unit) return end
  end

  if CursorHasItem() and button == "LeftButton" then
    DropItemOnUnit(unit)
    return
  end

  if string.find(action, "^menu") then
    CC:ShowMenu(unit)
    return
  end

  if string.find(action, "^target") then
    if UnitExists(unit) then TargetUnit(unit) end
    return
  end

  if not UnitExists(unit) then return end
  CC:Cast(action, unit)
end

local function ClickHandler()
  CC:OnClick(this, arg1)
end

-- ---------------------------------------------------------------------------
-- registration
-- ---------------------------------------------------------------------------
function CC:Register(frame, unit)
  if not CC.db then return nil end
  if type(frame) == "string" then frame = getglobal(frame) end
  if not frame or type(frame) ~= "table" then return nil end

  if unit then frame.ccUnit = unit end

  -- pfUI ships its own click casting; running both would double every cast
  if CC.db.takeover_pfui == "1" and frame.EnableClickCast then
    frame.clickactions = nil
    frame.EnableClickCast = function() return end
  end

  if CC.hooked[frame] then return true end

  -- RegisterForClicks only exists on Buttons, which is what we need
  if not frame.RegisterForClicks or not frame.SetScript or not frame.GetScript then
    return nil
  end

  CC.hooked[frame] = true
  CC.oldclick[frame] = frame:GetScript("OnClick")
  CC.hasmouse[frame] = (frame:GetScript("OnMouseDown") or frame:GetScript("OnMouseUp")) and true or nil

  frame:RegisterForClicks("LeftButtonUp", "RightButtonUp",
    "MiddleButtonUp", "Button4Up", "Button5Up")
  frame:SetScript("OnClick", ClickHandler)

  CC:Debug("hooked " .. (frame.GetName and frame:GetName() or "<unnamed>")
    .. " -> " .. (CC:GetUnit(frame) or "?"))

  return true
end

function CC:CountFrames()
  local count = 0
  for _ in pairs(CC.hooked) do count = count + 1 end
  return count
end

-- Clique compatible registration table: other addons can simply do
--   ClickCastFrames[myframe] = true
if type(ClickCastFrames) ~= "table" then ClickCastFrames = {} end
do
  local existing = ClickCastFrames
  setmetatable(existing, { __newindex = function(tbl, frame, value)
    rawset(tbl, frame, value)
    if value and CC.db then CC:Register(frame) end
  end })
end