Files
WeakestAuras/Widgets.lua
T
github-actions[bot] 1a384c3de8 WeakestAuras 0.11.0
WeakestAuras 0.11.0

Threat

- The Threat trigger no longer needs TWThreat installed. WeakestAuras asks the
  server for the threat table itself, and the trigger is now just called
  "Threat".
- Where another threat meter on your client is already asking, WeakestAuras
  stays quiet and reads its answers instead of adding a second request.
- Threat updates as soon as you switch target or pull, rather than on the next
  tick of a meter's timer.
- The trigger exposes the whole table: Aggro Race (%), Threat Until Swap,
  Threat Difference, Own Threat, Players Listed, Tanking, In Melee Range,
  Aggro Holder and their threat, Rival and their threat, and Target Name -- all
  usable in text replacements and conditions.
- Threat is only available for your current target, and not for normal mobs.
  The server answers no other request.

Per-aura warnings

- An aura that fails to compile, or that errors while running, is marked on its
  row in the aura list and named on its Info tab, instead of only printing to
  chat once.
- Auras that play a sound or use text-to-speech carry a mark of their own, so
  it is visible which of your auras will make noise.
- A trigger naming a spell that could not be resolved, a corrupt custom option,
  and an anchoring loop are each reported the same way.
- Hovering an aura's warning icon lists every message on it.

Sub-region anchoring

- Text, borders and glows on an Icon can be anchored to any of its 27 points.
  Icons previously offered nothing but "Whole region".
- A sub-region's anchor is now two controls: which part of the aura it attaches
  to, and which of its own points attaches there.
- WeakAuras2 auras carrying a combined anchor value are converted on import,
  and auras you imported before this release are converted when they load.
2026-08-18 08:56:11 +00:00

1743 lines
71 KiB
Lua

-- WeakestAuras -- shared widget factories and the declarative options-table
-- renderer. Widget look/feel (flat dark backdrop buttons, tooltip-style edit
-- boxes) follows the sibling Quartermaster config.
--
-- WA.Widgets.BuildOptions(page, fields) paints a whole tab's controls from a
-- plain array of field descriptors instead of hand-building a frame per field:
-- { type = "header"|"disclosure"|"toggle"|"input"|"multiline"|"range"|"select"
-- |"color"|"spell"|"item"|"icon"|"namelist"|"opnumber"|"button"|"menu"|"space"|"anchorgrid",
-- name = "...",
-- key = "...", -- stable field id, see below; omitted for header/button
-- get = function() end, set = function(value) end, -- color: get/set a {r,g,b,a}
-- half = true, -- pack two-per-row (any non-header type); default full row
-- min, max, step, -- range only
-- values, labels, -- select only: ordered values + optional value->label
-- swatches, -- select only: value -> texture path; each entry (and
-- -- the button face) previews it as a filled bar
-- getOp, setOp, getVal, setVal, -- opnumber only: operator select + number
-- onClick, width } -- button only: name is its label, width its pixel size
-- A `header` additionally takes `collapsed` (a bool -- present at all makes the
-- section collapsible: draws an up/down arrow, and the title line itself
-- toggles) with `onToggle`, `onDelete` (a two-click-confirm delete button), and
-- `actions` (icon buttons painted left-to-right on the right).
-- A `select` can also carry `actions`, which are painted beside its dropdown.
-- Collapsing is the *generator's* job: BuildOptions only paints the affordance,
-- so a collapsed section simply omits its body fields from the array it returns.
-- A `disclosure` folds the same way but is a control rather than a divider: a
-- gear leading a clickable one-line label, for settings that get set once and
-- then only get in the way. It takes the same `collapsed`/`onToggle`, plus
-- `summary` -- appended to `name` in grey, so the folded state still says what
-- the hidden rows hold.
-- A `range` is a spin box (LibWidgets.NewSpinBox), not a bare slider: `min`/
-- `max`/`step` drive the track, and the value is typeable inside it.
-- `code` is a `multiline` for user-authored Lua: syntax-coloured per keystroke
-- unless WeakestAurasDB.codeEditorLive is turned off (/wa codelive), in which
-- case colouring waits for blur. With
-- `height`, `validate(text) -> errOrNil` (a red line under the box, re-run on
-- every keystroke -- W.LuaSyntaxError is what both call sites pass) and
-- `default` (string or function; adds a two-click-confirm Reset button that
-- seeds the box back to it, and is what a never-configured field opens at --
-- committed, not just shown, which is why a `code` field's `get` returns the
-- raw stored value rather than `... or ""`: nil means never set, "" means the
-- user cleared it and must stay cleared). The error line and Reset belong to
-- the widget (LibWidgets.NewCodeEditBox), not to this renderer.
-- `spell` renders a spell-name/ID box with a live icon preview (numeric -> its
-- spell icon); `item` is the same idea keyed by WA.ResolveItemID/GetItemInfo
-- instead. `icon` is the same box but stores a resolved texture path (a
-- spellID resolves to its icon; a raw path is kept as-is) -- the manual-icon
-- picker's stopgap input until a browsing widget lands. `opnumber` is an
-- operator dropdown + number box on one line, for
-- "stacks >= N" style filters. `menu` is a drop button whose face stays fixed
-- at `name` (it labels an action, e.g. "+ Add Display Effect") and whose entries
-- are `values`/`labels`, calling `onSelect(value)` -- one control in place of a
-- row of near-identical add buttons. `namelist` is an add/remove/reorder list of
-- plain strings (LibWidgets.NewListEditor) -- `get` returns the live backing
-- array (mutated in place), `onChange` fires after any add/remove/reorder.
-- `half` lays a field in a two-column grid: the
-- first half goes left, the next right; a full-width field or header closes the
-- row. Columns size to the page's current width.
-- Region/trigger type option generators (Regions.lua, Triggers.lua) return one
-- of these arrays per aura; OptionsFrame.lua just hands it to BuildOptions.
--
-- Repaints reuse the widgets already on the page rather than minting new ones
-- (frames can't be destroyed on this client, so the old approach leaked a page
-- of controls per tab switch) -- see the widget pool below.
--
-- `key` is redundant with get/set today (BuildOptions never reads it) but is
-- deliberately kept in sync with the property each field actually reads/
-- writes (data.<key> for region fields, data.triggers[n].trigger.<key> for
-- trigger fields). get/set are closures bound to one
-- specific `data` table, so nothing outside that closure can tell which
-- property a field maps to; a future mass-edit-N-auras-at-once feature needs
-- that identity to wrap get/set as "read/write across every selected aura"
-- instead of one, without having to revisit every field definition in
-- Regions.lua/Triggers.lua a second time. Keep setting it on every new field.
if WeakestAuras.disabled then return end
local WA = WeakestAuras
WA.Widgets = {}
local W = WA.Widgets
local OPTIONS_INDENT_W = 14
-- Absolute path to the vendored LibWidgets textures. The library can't discover
-- its own path (no debug library here), so callers pass it in. Handed to widgets
-- that need their own art, e.g. the drop button's menu-affordance arrow.
W.LIBWIDGETS_TEXTURES = "Interface\\AddOns\\WeakestAuras\\libs\\LibWidgets\\textures\\"
W.DUPLICATE_TEXTURE = "Interface\\AddOns\\WeakestAuras\\textures\\duplicate.tga"
function W.DeleteAction(onClick)
return { icon = LibWidgets.ICON_DELETE, tooltip = "Delete", onClick = onClick }
end
function W.ListActions(list, index, onChanged, onDuplicate)
local actions = {}
table.insert(actions, { icon = W.DUPLICATE_TEXTURE, tooltip = "Duplicate", onClick = function()
if onDuplicate then
onDuplicate(list, index)
else
table.insert(list, index + 1, WA.DeepCopy(list[index]))
end
onChanged()
end })
table.insert(actions, { icon = W.LIBWIDGETS_TEXTURES .. "up", tooltip = "Move Up", onClick = function()
if index > 1 then
list[index - 1], list[index] = list[index], list[index - 1]
onChanged()
end
end })
table.insert(actions, { icon = W.LIBWIDGETS_TEXTURES .. "down", tooltip = "Move Down", onClick = function()
if index < table.getn(list) then
list[index + 1], list[index] = list[index], list[index + 1]
onChanged()
end
end })
table.insert(actions, W.DeleteAction(function()
table.remove(list, index)
onChanged()
end))
return actions
end
-- Status bar art. The names are LibWidgets' (so every consumer offers the same
-- set); the files are this addon's, for the same no-self-path reason as above.
W.BAR_TEXTURE_DIR = "Interface\\AddOns\\WeakestAuras\\textures\\bars\\"
-- Three-state eye for the aura list's forced-visibility toggle: full / partial /
-- empty. These are the frames WA2 reads out of Interface\LFGFrame, which this
-- client does not ship -- AshenBannerLFG had to vendor its own copies for its
-- minimap eye, which is why ours are vendored too rather than pathed at the
-- stock location. Referencing that addon's copies directly would blank the
-- indicator if it were ever uninstalled, and blank is indistinguishable from
-- the empty state.
W.EYE_TEXTURES = "Interface\\AddOns\\WeakestAuras\\textures\\eye\\"
-- The code editor's fixed-width face. Same no-self-path reason as above: the
-- library can't discover its own path, so the consumer supplies it. Vendored
-- under fonts\ (not a .toc entry -- see pack.ps1's $fontsDir block).
W.CODE_FONT = "Interface\\AddOns\\WeakestAuras\\fonts\\RobotoMono.ttf"
-- RobotoMono runs large for its nominal size, so the code boxes sit well below
-- the UI's usual body size. Only the default: WeakestAurasDB.codeEditorFontSize
-- overrides it (/wa codefont <6-16>), and the widget takes it per paint.
W.CODE_FONT_SIZE = 9
-- The client's own guild-MOTD horn, 16x16 and amber, which is also what a drop
-- button's row preview draws with nothing passed -- taken from the library rather
-- than respelled so the two cannot drift apart. Shared with the `sound` warning
-- severity, so the mark that means "play this" in the picker means "this aura
-- plays one" on the aura list's row.
--
-- Spelled out as a fallback because an older LibWidgets copy can win the version
-- race and publish no such field (see LIBWIDGETS_DEV).
W.SOUND_PREVIEW_TEXTURE = LibWidgets.PREVIEW_TEXTURE
or "Interface\\Buttons\\UI-GuildButton-MOTD-Up"
-- Falls back to the client's own bar art rather than erroring, so an older
-- LibWidgets copy winning the version race degrades a bar's *look* instead of
-- taking down the whole options paint (LibWidgetsProblem reports the real cause).
function W.BarTexturePath(name)
if not LibWidgets.BarTexturePath then return "Interface\\TargetingFrame\\UI-StatusBar" end
return LibWidgets.BarTexturePath(W.BAR_TEXTURE_DIR, name)
end
-- Bar textures this addon ships on top of LibWidgets' shared set. They stay
-- here rather than in LibWidgets.BAR_TEXTURES because that list is shared by
-- every addon vendoring the library, and only this one ships these files -- a
-- name added there would offer the other consumers a texture that resolves to
-- nothing.
local EXTRA_BAR_TEXTURES = {
"Clean", "Stripes", "ThinStripes", "ThickStripes",
"Armory", "Charcoal", "Cilo", "Comet", "Dabs", "DarkBottom",
"Diagonal", "Frost", "Glass", "Glaze", "Glaze2", "Grid", "Hatched",
"LiteStep", "Melli", "MelliDark", "Perl2", "Pill", "Smoothv2",
"Steel", "Striped", "Tube", "Water", "Wglass", "Wisps", "Xeon",
}
-- LibWidgets' set plus ours, built once. Every consumer of the bar list reads
-- this rather than LibWidgets.BAR_TEXTURES directly, or the two drift.
function W.BarTextures()
if not W.barTextures then
W.barTextures = {}
local shared = LibWidgets.BAR_TEXTURES or {}
for i = 1, table.getn(shared) do
table.insert(W.barTextures, shared[i])
end
for i = 1, table.getn(EXTRA_BAR_TEXTURES) do
table.insert(W.barTextures, EXTRA_BAR_TEXTURES[i])
end
end
return W.barTextures
end
-- value -> path map for a `select` field's `swatches`, built once.
function W.BarTextureSwatches()
if not W.barSwatches then
W.barSwatches = {}
local list = W.BarTextures()
for i = 1, table.getn(list) do
W.barSwatches[list[i]] = W.BarTexturePath(list[i])
end
end
return W.barSwatches
end
-- The LibWidgets surface this file is written against. Every addon vendoring
-- the library shares one global instance and the highest MINOR wins, so another
-- addon's older copy can be the one actually running here -- in which case the
-- first symptom is a nil call in the middle of a repaint, naming a function
-- rather than the version problem behind it. Check it once at load and record
-- what's missing; the options window reports it on open and `/wa libs` dumps
-- it (chat output at file-load time is unreliable on this client, so nothing is
-- printed from here). libs\LibWidgetsDev.lua is the escape hatch.
W.LIBWIDGETS_REQUIRED = {
"NewButton", "NewIconButton", "NewCheckBox", "NewColorSwatch", "NewTextBox",
"NewMultiLineEditBox", "NewScrollFrame", "NewScrollBar", "NewSpinBox", "NewDropButton",
"NewListEditor", "NewIconPicker", "GetIconDatabase", "CloseAllMenus", "ClearFocus",
"FormatNumber", "BarTexturePath",
"LuaColorize", "LuaEncode", "LuaDecode", "LuaStripColors",
"LuaPadWithLinebreaks", "LuaNextToken", "NewCodeEditBox", "NewAnchorGrid",
}
W.libWidgetsMissing = {}
for i = 1, table.getn(W.LIBWIDGETS_REQUIRED) do
local name = W.LIBWIDGETS_REQUIRED[i]
if not LibWidgets[name] then table.insert(W.libWidgetsMissing, name) end
end
-- One line describing which LibWidgets copy is live, or nil when it's fine.
function W.LibWidgetsProblem()
if table.getn(W.libWidgetsMissing) == 0 then return nil end
return "LibWidgets in use is MINOR " .. tostring(LibWidgets.MINOR or "?")
.. " and is missing " .. table.concat(W.libWidgetsMissing, ", ")
.. " -- another addon's older copy won the LibStub version race."
end
W.PANEL_BACKDROP = {
bgFile = "Interface\\DialogFrame\\UI-DialogBox-Background",
edgeFile = "Interface\\DialogFrame\\UI-DialogBox-Border",
tile = true, tileSize = 32, edgeSize = 16,
insets = { left = 5, right = 5, top = 5, bottom = 5 },
}
W.EDITBOX_BACKDROP = {
bgFile = "Interface\\Tooltips\\UI-Tooltip-Background",
edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
tile = true, tileSize = 16, edgeSize = 9,
insets = { left = 3, right = 3, top = 3, bottom = 3 },
}
-- ---------------------------------------------------------------------------
-- Base controls
--
-- Thin adapters over LibWidgets.New* (libs\LibWidgets) for the panel's own
-- chrome -- the controls that are built once and live for the session (search
-- box, tab strip, the buttons around the aura list). Everything inside the
-- options page itself goes through the pooled builders further down instead.
-- New *generic* controls belong in LibWidgets, not here.
-- ---------------------------------------------------------------------------
-- A live-filter edit box: fires onChange(text) on every keystroke and shows a
-- greyed "Search" hint while empty. Escape clears the text (not just focus),
-- which the shared NewTextBox leaves to the caller.
function W.searchbox(parent, width, onChange)
local e = LibWidgets.NewTextBox(parent, { width = width, height = 20, hint = "Search", onChange = onChange })
e:SetScript("OnEscapePressed", function() this:SetText(""); this:ClearFocus() end)
return e
end
function W.sectionHeader(parent, text)
local fs = parent:CreateFontString(nil, "ARTWORK", "GameFontNormalSmall")
fs:SetJustifyH("LEFT")
fs:SetText(text)
fs:SetTextColor(1, 0.82, 0)
return fs
end
function W.fieldLabel(parent, text)
local fs = parent:CreateFontString(nil, "ARTWORK", "GameFontNormalSmall")
fs:SetJustifyH("LEFT")
fs:SetText(text)
return fs
end
function W.button(parent, text, onClick)
return LibWidgets.NewButton(parent, { text = text, onClick = onClick })
end
-- Icon-only toolbar button. Mirrors WA2's WeakAurasToolbarButton, minus the
-- text label: its toolbar sits over a left column that grows with the window
-- (~290px at that addon's default size), ours over one fixed at 200, which has
-- room for icons and tooltips only.
--
-- setToggled marks the buttons standing for a persistent mode rather than a
-- one-shot action, matching the strong-highlight state upstream gives Lock
-- Positions and Magnetically Align.
-- `label`, when given, puts the caption beside the icon and widens the button to
-- fit it; without one the button stays the 22px square the icon fills. The
-- tooltip is kept either way -- it carries the second explanatory line a caption
-- has no room for.
function W.toolbarButton(parent, icon, tooltip, onClick, label)
local b = CreateFrame("Button", nil, parent)
b:SetWidth(22); b:SetHeight(22)
local on = b:CreateTexture(nil, "BACKGROUND")
on:SetAllPoints(b)
on:SetTexture(0.9, 0.8, 0.2, 0.25)
on:Hide()
-- 16px hard-sized and pinned left rather than inset from both corners: the
-- two agree exactly on an unlabelled 22px button, and only this form survives
-- the button growing to fit a caption.
local tex = b:CreateTexture(nil, "ARTWORK")
tex:SetWidth(16); tex:SetHeight(16)
tex:SetPoint("LEFT", b, "LEFT", 3, 0)
tex:SetTexture(icon)
b.icon = tex
if label then
local fs = b:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
fs:SetPoint("LEFT", tex, "RIGHT", 4, 0)
fs:SetJustifyH("LEFT")
fs:SetText(label)
b.label = fs
b:SetWidth(3 + 16 + 4 + (fs:GetStringWidth() or 0) + 6)
end
local hl = b:CreateTexture(nil, "HIGHLIGHT")
hl:SetAllPoints(b)
hl:SetTexture(1, 1, 1, 0.15)
function b.setToggled(v)
b.toggled = v and true or false
if b.toggled then on:Show() else on:Hide() end
end
b:SetScript("OnEnter", function()
GameTooltip:SetOwner(this, "ANCHOR_NONE")
GameTooltip:SetPoint("BOTTOMLEFT", this, "TOPLEFT", 0, 4)
GameTooltip:SetText(this.tipTitle or "", 1, 1, 1)
if this.tipDesc then GameTooltip:AddLine(this.tipDesc, 0.8, 0.8, 0.8, true) end
GameTooltip:Show()
end)
b:SetScript("OnLeave", function() GameTooltip:Hide() end)
b.tipTitle = tooltip
if onClick then b:SetScript("OnClick", onClick) end
return b
end
local QUESTION_ICON = "Interface\\Icons\\INV_Misc_QuestionMark"
-- The `disclosure` field's glyph. A stock item icon rather than vendored art:
-- 1.12 ships no gear in Interface\Buttons, and this one (Charged Gear, from
-- Gnomeregan) is a single cog that stays legible shrunk to a 9px button face.
local GEAR_ICON = "Interface\\Icons\\INV_Misc_Gear_01"
-- One shared icon-browser dialog behind every `icon` field's Browse button.
-- Built on first use, not at load: LibWidgets.GetIconDatabase's first call walks
-- the client's whole icon set, which is not worth paying for unless the user
-- actually opens the picker. The pick is routed through a stored callback rather
-- than rebuilding the dialog per field.
function W.OpenIconPicker(current, onPick)
if not LibWidgets.NewIconPicker then
DEFAULT_CHAT_FRAME:AddMessage("|cffff4040WeakestAuras:|r "
.. (W.LibWidgetsProblem() or "the loaded LibWidgets has no NewIconPicker."))
return
end
if not W.iconPicker then
W.iconPicker = LibWidgets.NewIconPicker(UIParent, {
nameFrame = "WeakestAurasIconPicker",
title = "Select Icon",
onAccept = function(path)
if W.onIconPicked then W.onIconPicked(path) end
end,
})
end
W.onIconPicked = onPick
W.iconPicker.Open(current)
end
local TEXTURE_PATH_PREFIX = "Interface\\AddOns\\WeakestAuras\\textures\\"
local TEXTURE_CATEGORIES = {
Shapes = {
"arrows_target.tga", "Circle_AlphaGradient_In.tga", "Circle_AlphaGradient_Out.tga", "circle_border5.tga",
"Circle_Smooth.tga", "Circle_Smooth2.tga", "Circle_Smooth_Border.tga", "Circle_Squirrel.tga", "Circle_Squirrel_Border.tga",
"Circle_White.tga", "Circle_White_Border.tga", "Ring_10px.tga", "Ring_20px.tga", "Ring_30px.tga", "Ring_40px.tga",
"ring_glow3.tga", "Square_AlphaGradient.tga", "square_border_10px.tga", "square_border_1px.tga", "square_border_5px.tga",
"Square_FullWhite.tga", "square_mini.tga", "Square_Smooth.tga", "Square_Smooth_Border.tga", "Square_Squirrel.tga",
"Square_Squirrel_Border.tga", "Square_White.tga", "Square_White_Border.tga", "target_indicator.tga",
"target_indicator_glow.tga", "Trapezoid.tga", "triangle-border.tga", "triangle.tga", "Triangle45.tga",
},
Alerts = {
"ArcaneMissiles.blp", "ArcaneMissiles1.blp", "ArcaneMissiles2.blp", "ArcaneMissiles3.blp", "ArcaneSoul.blp",
"ArtOfWar.blp", "BacklashGreen.blp", "Backslash.blp", "BanditsGuile.blp", "Berserk.blp",
"BloodBoil.blp", "BloodSurge.blp", "BrainFreeze.blp", "DarkTiger.blp", "DarkTransformation.blp", "Daybreak.blp",
"DemonicCore.blp", "DemonicCoreVertical.blp", "Denounce.blp", "EchoOfTheElements.blp", "EclipseMoon.blp", "EclipseSun.blp",
"EssenceBurst.blp", "FocusFire.blp", "FrozenFingers.blp", "Fulmination.blp", "FuryOfStormrage.blp", "GenericArc1.blp",
"GenericArc2.blp", "GenericArc3.blp", "GenericArc4.blp", "GenericArc5.blp", "GenericArc6.blp", "GenericTop1.blp",
"GenericTop2.blp", "GrandCrusader.blp", "HandOfLight.blp", "HighTide.blp", "HotStreak.blp", "Hyperthermia.blp",
"ImpEmpowerment.blp", "ImpEmpowermentGreen.blp", "Impact.blp", "KillingMachine.blp", "LockAndLoad.blp", "MaelstromWeapon.blp",
"MaelstromWeapon1.blp", "MaelstromWeapon2.blp", "MaelstromWeapon3.blp", "MaelstromWeapon4.blp", "MasterMarksman.blp",
"MoltenCore.blp", "MonkBlackoutKick.blp", "MonkOx.blp", "MonkOx2.blp", "MonkOx3.blp", "MonkSerpent.blp",
"MonkTiger.blp", "MonkTigerPalm.blp", "NatureSGrace.blp", "Necropolis.blp", "Nightfall.blp", "PredatorySwiftness.blp",
"OmenOfClarityFeral.blp", "PredatorySwiftnessGreen.blp", "RagingBlow.blp", "Rime.blp", "Serendipity.blp", "ShadowOfDeath.blp",
"ShadowWordInsanity.blp", "ShootingStars.blp",
"SliceAndDice.blp", "Snapfire.blp", "SuddenDeath.blp", "SuddenDoom.blp", "SurgeOfDarkness.blp", "SurgeOfLight.blp",
"SpellActivationOverlay0.blp", "SwordAndBoard.blp", "ThrillOfTheHunt1.blp", "ThrillOfTheHunt2.blp", "ThrillOfTheHunt3.blp", "ToothAndClaw.blp",
"Ultimatum.blp", "WhiteTiger.blp",
},
-- Power Auras art, split the four ways upstream splits it. Every name here
-- also has to be reachable from WA2Import's rewrite of an incoming
-- PowerAurasMedia\Auras path, which looks the basename up in this table --
-- so a file dropped from here stops resolving on import as well as in the
-- picker. Aura146-246 exist upstream of WeakAuras2 but not in it, and are
-- not bundled: see textures/README.md.
PowerAurasHeadsUp = {
"Aura1.tga", "Aura2.tga", "Aura3.tga", "Aura4.tga", "Aura5.tga", "Aura6.tga", "Aura7.tga",
"Aura11.tga", "Aura16.tga", "Aura17.tga", "Aura18.tga", "Aura23.tga", "Aura24.tga", "Aura28.tga",
"Aura33.tga",
},
PowerAurasIcons = {
"Aura8.tga", "Aura9.tga", "Aura10.tga", "Aura12.tga", "Aura13.tga", "Aura14.tga", "Aura15.tga",
"Aura19.tga", "Aura21.tga", "Aura22.tga", "Aura25.tga", "Aura26.tga", "Aura27.tga", "Aura29.tga",
"Aura30.tga", "Aura31.tga", "Aura32.tga", "Aura34.tga", "Aura35.tga", "Aura36.tga", "Aura45.tga",
"Aura48.tga", "Aura49.tga", "Aura50.tga", "Aura51.tga", "Aura52.tga", "Aura53.tga", "Aura54.tga",
"Aura68.tga", "Aura69.tga", "Aura70.tga", "Aura71.tga", "Aura72.tga", "Aura73.tga", "Aura74.tga",
"Aura75.tga", "Aura76.tga", "Aura77.tga", "Aura78.tga", "Aura79.tga", "Aura84.tga", "Aura85.tga",
"Aura86.tga", "Aura87.tga", "Aura88.tga", "Aura95.tga", "Aura96.tga", "Aura97.tga", "Aura98.tga",
"Aura99.tga", "Aura100.tga", "Aura101.tga", "Aura102.tga", "Aura103.tga", "Aura110.tga",
"Aura111.tga", "Aura112.tga", "Aura113.tga", "Aura114.tga", "Aura115.tga", "Aura116.tga",
"Aura117.tga", "Aura118.tga", "Aura119.tga", "Aura120.tga", "Aura130.tga", "Aura131.tga",
"Aura132.tga", "Aura138.tga", "Aura139.tga", "Aura140.tga", "Aura141.tga", "Aura142.tga",
"Aura143.tga",
},
PowerAurasSeparated = {
"Aura46.tga", "Aura47.tga", "Aura55.tga", "Aura56.tga", "Aura57.tga", "Aura58.tga", "Aura59.tga",
"Aura60.tga", "Aura61.tga", "Aura62.tga", "Aura63.tga", "Aura64.tga", "Aura65.tga", "Aura66.tga",
"Aura67.tga", "Aura80.tga", "Aura81.tga", "Aura82.tga", "Aura83.tga", "Aura89.tga", "Aura90.tga",
"Aura91.tga", "Aura92.tga", "Aura93.tga", "Aura94.tga", "Aura104.tga", "Aura105.tga", "Aura106.tga",
"Aura107.tga", "Aura108.tga", "Aura109.tga", "Aura121.tga", "Aura122.tga", "Aura123.tga",
"Aura124.tga", "Aura125.tga", "Aura126.tga", "Aura127.tga", "Aura128.tga", "Aura129.tga",
"Aura133.tga", "Aura134.tga", "Aura135.tga", "Aura136.tga", "Aura137.tga", "Aura144.tga",
"Aura145.tga",
},
PowerAurasWords = {
"Aura20.tga", "Aura37.tga", "Aura38.tga", "Aura39.tga", "Aura40.tga", "Aura41.tga", "Aura42.tga",
"Aura43.tga", "Aura44.tga",
},
}
WA.textureTypes = TEXTURE_CATEGORIES
-- All four Power Auras categories draw from one folder, so the category name
-- cannot be lowercased into the path the way Shapes and Alerts are.
local TEXTURE_CATEGORY_DIRS = {
PowerAurasHeadsUp = "powerauras", PowerAurasIcons = "powerauras",
PowerAurasSeparated = "powerauras", PowerAurasWords = "powerauras",
}
local TEXTURE_CATEGORY_VALUES = {
"Alerts", "Shapes",
"PowerAurasHeadsUp", "PowerAurasIcons", "PowerAurasSeparated", "PowerAurasWords",
}
local TEXTURE_CATEGORY_LABELS = {
Alerts = "Blizzard Alerts", Shapes = "Shapes",
PowerAurasHeadsUp = "Power Auras: Heads-Up", PowerAurasIcons = "Power Auras: Icons",
PowerAurasSeparated = "Power Auras: Separated", PowerAurasWords = "Power Auras: Words",
}
-- Full path to one bundled texture. Public because WA2Import builds its rewrite
-- index off WA.textureTypes and has to form the same paths the picker stores.
function W.TexturePath(category, name)
local dir = TEXTURE_CATEGORY_DIRS[category] or string.lower(category)
return TEXTURE_PATH_PREFIX .. dir .. "\\" .. name
end
local texturePath = W.TexturePath
-- lowercased file name -> the category holding it, for the categories whose
-- folder does not name them. Built on first use, since the four Power Auras
-- lists share one folder and the path alone cannot say which tab to open on.
local powerAurasCategory
local function powerAurasCategoryFor(name)
if not powerAurasCategory then
powerAurasCategory = {}
for i = 1, table.getn(TEXTURE_CATEGORY_VALUES) do
local category = TEXTURE_CATEGORY_VALUES[i]
if TEXTURE_CATEGORY_DIRS[category] == "powerauras" then
local list = TEXTURE_CATEGORIES[category]
for j = 1, table.getn(list) do
powerAurasCategory[string.lower(list[j])] = category
end
end
end
end
return powerAurasCategory[string.lower(name or "")]
end
function W.OpenTexturePicker(current, onPick)
if not LibWidgets.NewIconPicker then
DEFAULT_CHAT_FRAME:AddMessage("|cffff4040WeakestAuras:|r "
.. (W.LibWidgetsProblem() or "the loaded LibWidgets has no texture picker support."))
return
end
if not W.texturePicker then
W.texturePicker = LibWidgets.NewIconPicker(UIParent, {
nameFrame = "WeakestAurasTexturePicker",
title = "Select Texture",
categories = TEXTURE_CATEGORIES,
categoryValues = TEXTURE_CATEGORY_VALUES,
categoryLabels = TEXTURE_CATEGORY_LABELS,
defaultCategory = "Shapes",
pathFor = function(name, category) return texturePath(category or "Shapes", name) end,
normalize = function(value)
local _, _, name = string.find(string.lower(value or ""), "textures\\[^\\]+\\([^\\]+)$")
return name or value
end,
categoryFor = function(value)
local lower = string.lower(value or "")
if string.find(lower, "textures\\alerts\\", 1, true) then return "Alerts" end
if string.find(lower, "textures\\powerauras\\", 1, true) then
local _, _, name = string.find(lower, "([^\\]+)$")
return powerAurasCategoryFor(name) or "PowerAurasIcons"
end
return "Shapes"
end,
labelFor = function(name) return name end,
onAccept = function(path)
if W.onTexturePicked then W.onTexturePicked(path) end
end,
})
end
W.onTexturePicked = onPick
W.texturePicker.Open(current)
end
function W.CloseTexturePicker()
if W.texturePicker then W.texturePicker.Close() end
end
function W.CloseIconPicker()
if W.iconPicker then W.iconPicker.Close() end
end
-- Comparison operators offered by opnumber fields; the same set the runtime
-- cmp() in TriggerAura understands.
W.OPERATORS = { "==", "~=", "<", "<=", ">", ">=" }
-- Compiles `source` and returns "line N: message", or nil when it parses --
-- the `validate` hook a user-authored-Lua field hands to BuildOptions.
--
-- `chunkName` is what Lua puts inside the error's `[string "..."]:LINE:`
-- prefix, so keeping it short and caller-supplied makes stripping that prefix a
-- plain (non-pattern) find instead of a pattern that would have to survive
-- whatever the user typed. Callers that wrap the body ("return " .. body) must
-- use a prefix containing **no newline**, or every reported line is off by one.
function W.LuaSyntaxError(source, chunkName)
local chunk, err = loadstring(source or "", chunkName or "code")
if chunk then return nil end
if not err then return "syntax error" end
-- Lua 5.0 error strings are `[string "name"]:LINE: message`. Take the last
-- "]:" so a chunk name containing one can't cut the prefix short.
local last, from = nil, 1
while true do
local s, e = string.find(err, "]:", from, true)
if not s then break end
last = e
from = s + 1
end
if not last then return err end
local rest = string.sub(err, last + 1)
if string.find(rest, "^%d+") then return "line " .. rest end
return rest
end
local EMPTY = {}
-- ---------------------------------------------------------------------------
-- Widget pool
--
-- Frames can't be destroyed on this client, so a repaint that minted a fresh
-- widget per field and merely hid the previous set leaked a full page of
-- controls on every tab/aura switch -- and not cheaply: a single dropdown
-- brings a popup frame, a scroll frame and one button per menu entry with it,
-- and the slider and list editor each burn a unique *global* frame name per
-- instance (their Blizzard templates address child frames by name).
--
-- Widgets are therefore acquired from a per-kind free list kept on the page and
-- rebound to whatever field is being painted. Each pooled widget is built once
-- around a `bind` table this file owns, and every callback handed to LibWidgets
-- is an indirection that reads the current binding out of it -- so rebinding is
-- just overwriting `bind` fields, with no library-side support needed.
--
-- `kind` folds in any parameter a widget can only take at construction (a
-- dropdown's width, a list editor's visible row count), so an instance is only
-- ever reused where those still hold.
-- ---------------------------------------------------------------------------
local function acquire(page, kind, create)
local pool = page.widgetPools[kind]
if not pool then pool = {}; page.widgetPools[kind] = pool end
local n = (page.widgetUsed[kind] or 0) + 1
page.widgetUsed[kind] = n
local w = pool[n]
if not w then
w = create()
pool[n] = w
end
w:ClearAllPoints()
w:Show()
return w
end
local function poolLabel(page, text)
local fs = acquire(page, "label", function() return W.fieldLabel(page, "") end)
fs:SetText(text or "")
return fs
end
-- A wrapping explanatory line under a field. Pooled apart from `label` because
-- it carries a wrap width, which a plain label reused from the same pool would
-- inherit and then wrap inside its own row.
local function poolDescription(page, text, width)
local fs = acquire(page, "desc", function()
local f = page:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall")
f:SetJustifyH("LEFT")
f:SetTextColor(0.6, 0.6, 0.6)
return f
end)
fs:SetWidth(width)
fs:SetText(text or "")
return fs
end
local function poolHeaderLabel(page, text)
local fs = acquire(page, "headerlabel", function() return W.sectionHeader(page, "") end)
fs:SetText(text or "")
return fs
end
local function poolRule(page)
return acquire(page, "rule", function()
local t = page:CreateTexture(nil, "ARTWORK")
t:SetHeight(1)
t:SetTexture(0.9, 0.75, 0.2, 0.45)
return t
end)
end
-- The 18px spell/item/icon preview swatch beside a text field.
local function poolPreviewIcon(page)
return acquire(page, "previewicon", function()
local t = page:CreateTexture(nil, "OVERLAY")
t:SetWidth(18); t:SetHeight(18)
t:SetTexCoord(0.07, 0.93, 0.07, 0.93)
return t
end)
end
local function poolCheck(page, text, onClick, get)
local cb = acquire(page, "check", function()
local bind = {}
local w = LibWidgets.NewCheckBox(page, {
onClick = function(v) if bind.onClick then bind.onClick(v) end end,
})
w.bind = bind
return w
end)
cb.bind.onClick = onClick
cb.label:SetText(text or "")
cb.setChecked(get and get())
return cb
end
-- Shift-clicking an item drops its link into whichever field is focused and has
-- asked for links (the item fields). `HandleModifiedItemClick` is the real entry
-- point on this client -- it forwards to `ChatEdit_InsertLink` only while the
-- *chat* edit box is visible, so wrapping `ChatEdit_InsertLink` alone never sees
-- a link bound for one of ours. Both are wrapped: the second still carries a
-- link clicked in chat, which arrives there directly. Quartermaster's config
-- intercepts the same pair for the same reason.
local linkSink
-- The itemID is stored rather than the link or the name: an id always resolves,
-- where a name has to be found in the player's bags first. The readable name
-- comes back through the trigger's own nameFunc, so nothing is lost on screen.
local function routeLink(text)
if not text or not linkSink or not linkSink:IsVisible() then return false end
local _, _, id = string.find(text, "item:(%d+)")
if not id then return false end
linkSink:SetText(id)
linkSink:SetFocus()
if linkSink.bind and linkSink.bind.onCommit then linkSink.bind.onCommit(id) end
return true
end
local origModifiedClick = HandleModifiedItemClick
function HandleModifiedItemClick(link)
if link and IsModifiedClick("CHATLINK") and routeLink(link) then return true end
if origModifiedClick then return origModifiedClick(link) end
end
local origInsertLink = ChatEdit_InsertLink
function ChatEdit_InsertLink(text)
if routeLink(text) then return true end
if origInsertLink then return origInsertLink(text) end
return false
end
local function poolEditBox(page, width, onCommit)
local e = acquire(page, "editbox", function()
local bind = {}
local w = LibWidgets.NewTextBox(page, {
height = 20,
onCommit = function(t) if bind.onCommit then bind.onCommit(t) end end,
})
w.bind = bind
-- Chained, not replaced: the library's own handler closes open menus.
local origFocus = w:GetScript("OnEditFocusGained")
w:SetScript("OnEditFocusGained", function()
if origFocus then origFocus() end
linkSink = this.acceptsLinks and this or nil
end)
w:SetScript("OnEditFocusLost", function()
if linkSink == this then linkSink = nil end
end)
return w
end)
e.bind.onCommit = onCommit
-- One pool serves every field, so a box that last served an item field must
-- not keep accepting links on behalf of the next one.
e.acceptsLinks = false
e:SetWidth(width)
-- A reused box may still hold focus from the edit that triggered this
-- repaint; its text is about to be replaced under the cursor either way.
e:ClearFocus()
return e
end
local function poolButton(page, text, width, onClick)
local b = acquire(page, "button", function() return LibWidgets.NewButton(page, {}) end)
b.setText(text)
b:SetWidth(width or 80)
-- NewButton's own OnMouseDown already closes any open menu, so rebinding
-- only OnClick here loses nothing.
b:SetScript("OnClick", onClick or function() end)
return b
end
-- The small texture-faced buttons on a collapsible header (arrow, actions, delete) and on
-- a disclosure line (gear). The tint is reset on every acquisition, since one
-- pool serves all of them and a dimmed disclosure gear would otherwise carry
-- over onto whatever header arrow lands on that instance next.
local function poolIconButton(page, icon, onClick, tooltip)
local b = acquire(page, "iconbutton", function()
local w = LibWidgets.NewIconButton(page, { width = 16, height = 16, iconSize = 9 })
w.baseOnEnter = w:GetScript("OnEnter")
w.baseOnLeave = w:GetScript("OnLeave")
return w
end)
b.icon:SetTexture(icon)
b.icon:SetVertexColor(1, 1, 1)
b:SetScript("OnClick", function() LibWidgets.CloseAllMenus(); if onClick then onClick() end end)
b:SetScript("OnEnter", function()
if b.baseOnEnter then b.baseOnEnter() end
if tooltip and tooltip ~= "" then
GameTooltip:SetOwner(b, "ANCHOR_RIGHT")
GameTooltip:AddLine(tooltip)
GameTooltip:Show()
end
end)
b:SetScript("OnLeave", function()
if b.baseOnLeave then b.baseOnLeave() end
GameTooltip:Hide()
end)
return b
end
-- A section header's delete button, armed by a first click and committed by a
-- second within 3s -- the same two-click confirm the aura list's own Delete
-- uses, since deleting a trigger/effect/condition is just as unrecoverable. A
-- 16px icon button has no label to morph into "Confirm?" and a tinted 9px glyph
-- is too small to read as a state change, so an armed button goes solid red --
-- backdrop, border and glyph together -- which is legible at a glance and can't
-- be mistaken for the hover highlight.
local function poolDeleteButton(page, onDelete)
local b = acquire(page, "delbutton", function()
local bind = {}
local w = LibWidgets.NewIconButton(page, { width = 16, height = 16, iconSize = 9 })
w.icon:SetTexture(LibWidgets.ICON_DELETE)
w.bind = bind
w.arm = function()
w.armed = true
w:SetBackdropColor(0.65, 0.06, 0.06, 1)
w:SetBackdropBorderColor(1, 0.3, 0.3, 1)
w.icon:SetVertexColor(1, 0.9, 0.9)
end
w.disarm = function()
w.armed = nil
w:SetBackdropColor(0, 0, 0, 0.7)
w:SetBackdropBorderColor(0.4, 0.4, 0.4, 0.8)
w.icon:SetVertexColor(1, 1, 1)
end
w:SetScript("OnClick", function()
LibWidgets.CloseAllMenus()
if w.armed then
w.disarm()
if bind.onDelete then bind.onDelete() end
else
w.arm()
C_Timer.After(3, function() if w.armed then w.disarm() end end)
end
end)
-- Hover must not repaint an armed button back to the neutral border, or
-- moving the mouse would silently undo the only cue that it's primed.
w:SetScript("OnEnter", function()
if not w.armed then this:SetBackdropBorderColor(0.9, 0.8, 0.2, 1) end
GameTooltip:SetOwner(this, "ANCHOR_RIGHT")
GameTooltip:AddLine(w.armed and "Click again to confirm" or "Delete")
GameTooltip:Show()
end)
w:SetScript("OnLeave", function()
if not w.armed then this:SetBackdropBorderColor(0.4, 0.4, 0.4, 0.8) end
GameTooltip:Hide()
end)
return w
end)
b.bind.onDelete = onDelete
-- Disarm on reuse: a pooled button armed for the section it served in the
-- last paint must never commit that click against whatever section it lands
-- on in this one.
b.disarm()
return b
end
local function poolActionButton(page, action)
if action.confirm then return poolDeleteButton(page, action.onClick) end
return poolIconButton(page, action.icon, action.onClick, action.tooltip)
end
-- A bare click target laid over a collapsible header's title line.
local function poolHitArea(page, onClick)
local b = acquire(page, "hitarea", function() return CreateFrame("Button", nil, page) end)
b:SetHeight(16)
b:SetScript("OnClick", onClick)
return b
end
-- `swatches` (value -> texture path) turns this into a previewing picker; a
-- swatch button can't be un-swatched after construction, so it pools separately.
local function poolDropdown(page, width, values, labels, onSelect, get, swatches, previews, onPreview)
local kind = (swatches and "dropsw" or previews and "droppreview" or "drop") .. width
local d = acquire(page, kind, function()
local bind = {}
-- NewDropButton captures `labels` once; a proxy that forwards misses to
-- the live binding is what lets one pooled button serve every field.
-- `values` needs no such trick -- passed as a function it already means
-- "rebuild the menu from this on every open".
local labelProxy = setmetatable({}, { __index = function(t, k)
if k == nil then return nil end
return bind.labels and bind.labels[k]
end })
local swatchProxy = swatches and setmetatable({}, { __index = function(t, k)
if k == nil then return nil end
return bind.swatches and bind.swatches[k]
end })
local previewProxy = previews and setmetatable({}, { __index = function(t, k)
if k == nil then return nil end
return bind.previews and bind.previews[k]
end })
local w = LibWidgets.NewDropButton(page, {
width = width,
values = function() return bind.values or EMPTY end,
labels = labelProxy,
swatches = swatchProxy,
previews = previewProxy,
previewTexture = W.SOUND_PREVIEW_TEXTURE,
onPreview = function(v) if bind.onPreview then bind.onPreview(v) end end,
onSelect = function(v) if bind.onSelect then bind.onSelect(v) end end,
get = function() return bind.get and bind.get() end,
textureDir = W.LIBWIDGETS_TEXTURES,
-- The library's default of 8 rows scrolls the longest lists here (the
-- trigger-type picker, a condition's property list) far more than they
-- need. Read once at construction, so it applies to every field this
-- pooled button is later rebound to.
maxVisibleItems = 14,
})
w.bind = bind
return w
end)
d.bind.values = values
d.bind.labels = labels
d.bind.swatches = swatches
d.bind.previews = previews
d.bind.onPreview = onPreview
d.bind.onSelect = onSelect
d.bind.get = get
d.setValue(get and get())
return d
end
local function poolAnchorGrid(page, f, width)
local grid = acquire(page, "anchorgrid", function()
local bind = {}
local w = LibWidgets.NewAnchorGrid(page, {
values = f.values,
get = function() return bind.get and bind.get() end,
onSelect = function(v) if bind.set then bind.set(v) end end,
})
w.bind = bind
return w
end)
grid.bind.get = f.get
grid.bind.set = f.set
grid.setBindings(f.values, function() return grid.bind.get and grid.bind.get() end,
function(v) if grid.bind.set then grid.bind.set(v) end end)
grid.setSize(f.width or 100, f.height or 50)
grid.setValue(f.get())
return grid
end
-- A drop button whose face never changes: it names an action and its entries
-- are the choices. NewDropButton repaints the face from the picked value only
-- when given a `get`, so omitting one leaves the face entirely to setValue --
-- which this calls with the caption on every paint.
local function poolMenuButton(page, width, caption, values, labels, onSelect)
local d = acquire(page, "menu" .. width, function()
local bind = {}
local labelProxy = setmetatable({}, { __index = function(t, k)
if k == nil then return nil end
return bind.labels and bind.labels[k]
end })
local w = LibWidgets.NewDropButton(page, {
width = width,
values = function() return bind.values or EMPTY end,
labels = labelProxy,
onSelect = function(v) if bind.onSelect then bind.onSelect(v) end end,
textureDir = W.LIBWIDGETS_TEXTURES,
})
w.bind = bind
return w
end)
d.bind.values = values
d.bind.labels = labels
d.bind.onSelect = onSelect
-- No label maps the caption, so setValue falls through to the caption itself.
d.setValue(caption)
return d
end
local function poolColor(page, get, set)
local sw = acquire(page, "color", function()
local bind = {}
local w = LibWidgets.NewColorSwatch(page, {
get = function() return bind.get and bind.get() end,
set = function(v) if bind.set then bind.set(v) end end,
})
w.bind = bind
return w
end)
sw.bind.get = get
sw.bind.set = set
sw.repaint()
return sw
end
-- A syntax-coloured Lua editor. The error line and the Reset button are the
-- widget's own (see LibWidgets.NewCodeEditBox), so nothing here pools them
-- separately -- which is also what keeps them from being stranded by a repaint.
-- Height is a construction-time parameter, so it folds into the pool key.
local function poolCode(page, f, width, height)
local box = acquire(page, "code" .. height, function()
local bind = {}
local w = LibWidgets.NewCodeEditBox(page, {
width = width, height = height,
font = { path = W.CODE_FONT, size = W.CODE_FONT_SIZE },
onChange = function(t) if bind.onChange then bind.onChange(t) end end,
onCommit = function(t) if bind.onCommit then bind.onCommit(t) end end,
validate = function(t) return bind.validate and bind.validate(t) end,
})
w.bind = bind
return w
end)
-- Unbound across the seed: setText re-validates and would otherwise run the
-- previous field's validator against this field's text.
box.bind.onChange, box.bind.onCommit, box.bind.validate = nil, nil, nil
box.setSize(width, height)
-- Read per paint rather than at construction, so /wa codelive takes effect on
-- the next repaint instead of needing a reload. `false` is a real stored
-- value, so this can't collapse to `or true` -- only an unset (nil) setting
-- falls back to the default, the same shape as the tab width below.
if box.setLive then
local liveOn = WeakestAurasDB and WeakestAurasDB.codeEditorLive
if liveOn == nil then liveOn = true end
box.setLive(liveOn)
end
if box.setFontSize then
box.setFontSize((WeakestAurasDB and WeakestAurasDB.codeEditorFontSize) or W.CODE_FONT_SIZE)
end
if box.setTabWidth then
-- `false` means hard tabs, so this can't collapse to `or 2` -- only an
-- unset (nil) value falls back to the default.
local tw = WeakestAurasDB and WeakestAurasDB.codeEditorTabWidth
if tw == nil then tw = 2 end
box.setTabWidth(tw)
end
-- setDefault also disarms, so a Reset primed for the field this box served
-- in the last paint can never commit against the one it lands on now.
box.setDefault(f.default)
-- A field that has never been configured opens *at* its Reset default rather
-- than empty: an empty box runs nothing and teaches nothing, and the default
-- is the signature the user has to start from either way. It is committed,
-- not merely displayed -- a box showing logic the aura is not running is
-- worse than an empty one -- so it goes through `set` once the binds are
-- back.
--
-- "Never configured" is `get` returning nil, and the distinction from "" is
-- load-bearing: seeding an empty *string* would put the default back every
-- time the user cleared the box, which makes an emptied code field
-- impossible to keep. A `code` field's `get` must therefore return the raw
-- stored value, not `... or ""`.
local stored = f.get()
local seeding = (stored == nil and f.default ~= nil)
local text = stored or ""
if seeding then
text = (type(f.default) == "function" and f.default() or f.default) or ""
end
box.setText(text)
box.bind.validate = f.validate
box.bind.onCommit = f.set
box.bind.onChange = f.onChange
if seeding and f.set then f.set(text) end
-- The seed above ran with no validator bound; drive the error line now that
-- the real one is in place.
box.revalidate()
return box
end
local function poolMultiline(page, width, height, text, onCommit, onChange)
local box = acquire(page, "multiline", function()
local bind = {}
local w = LibWidgets.NewMultiLineEditBox(page, {
onChange = function(t) if bind.onChange then bind.onChange(t) end end,
})
w.bind = bind
w.edit:SetScript("OnEditFocusLost", function()
if bind.onCommit then bind.onCommit(w.getText()) end
end)
return w
end)
-- Unbound across the seed: SetText fires OnTextChanged, and the field being
-- painted validates its own starting text below -- an echo here would only
-- run the same check a second time (and, before the rebind, against the
-- previous field's).
box.bind.onChange = nil
box.bind.onCommit = nil
-- setSize, not SetWidth/SetHeight: the widget has to re-wrap and re-measure
-- its text to keep the scroll range right.
box.setSize(width, height)
box.setText(text or "")
box.bind.onChange = onChange
box.bind.onCommit = onCommit
return box
end
-- Boundary-move splice shared by the list editor's arrow buttons and its
-- drag-drop (see LibWidgets.lua's NewListEditor doc comment): `before` names an
-- original index the moved entry should land just ahead of.
local function spliceReorder(list, fromIndex, before)
local v = table.remove(list, fromIndex)
local insertAt = (fromIndex < before) and (before - 1) or before
table.insert(list, insertAt, v)
end
local function poolListEditor(page, f, x, y, rightInset, visibleRows)
local frame = acquire(page, "list" .. visibleRows, function()
W._listSeq = (W._listSeq or 0) + 1
local bind = {}
local function list() return (bind.list and bind.list()) or EMPTY end
local function changed(kind, first, second)
if bind[kind] then
if second ~= nil then bind[kind](first, second) else bind[kind](first) end
elseif bind.onChange then
bind.onChange()
end
end
local editor = LibWidgets.NewListEditor(page, {
nameFrame = "WeakestAurasOptList" .. W._listSeq,
textureDir = W.LIBWIDGETS_TEXTURES,
rowHeight = 20, visibleRows = visibleRows,
list = list,
reorder = function(fromIndex, before)
spliceReorder(list(), fromIndex, before)
changed("onReorder", fromIndex, before)
end,
remove = function(index)
table.remove(list(), index)
changed("onRemove", index)
end,
add = { onAdd = function(text)
if text and text ~= "" then
table.insert(list(), text)
changed("onAdd", text)
end
end },
nameGet = function(entry) return entry end,
})
editor.frame.editor = editor
editor.frame.bind = bind
return editor.frame
end)
frame.bind.list = f.get
frame.bind.onChange = f.onChange
frame.bind.onReorder = f.onReorder
frame.bind.onRemove = f.onRemove
frame.bind.onAdd = f.onAdd
frame:SetPoint("TOPLEFT", page, "TOPLEFT", x, y)
frame:SetPoint("RIGHT", page, "RIGHT", -rightInset, 0)
frame.editor.refresh()
return frame
end
-- ---------------------------------------------------------------------------
-- Declarative options-table renderer
-- ---------------------------------------------------------------------------
-- Distance from a field's top edge down to the top of its control body -- the
-- caption line a labelled field draws above its widget, zero for one that has
-- none. A two-column row aligns on this rather than on its top edge, so a bare
-- toggle or swatch sits level with the control beside it instead of level with
-- that control's caption. `range` is listed although `placeField` puts its
-- widget on the row's top edge: NewSpinBox draws its own caption inside the
-- frame, in the 14px it reserves above the track.
local FIELD_LEAD = {
input = 16, multiline = 16, namelist = 16, select = 16, opnumber = 16,
spell = 16, item = 16, talent = 16, icon = 16, texture = 16,
anchorgrid = 16, anchorlayout = 16,
code = 20,
range = 14,
}
local function fieldLead(f) return FIELD_LEAD[f.type] or 0 end
-- Places one field at (x, y) with widget width `w` and returns the vertical
-- space it consumed. Headers are handled by the caller (they're always
-- full-width). Shared by the single-column and two-column paths so both stay
-- identical per field type.
local function placeField(page, f, x, y, w)
local indent = (f.indent or 0) * OPTIONS_INDENT_W
if indent > 0 then
x = x + indent
w = w - indent
if w < 90 then w = 90 end
end
local lead = fieldLead(f)
if f.type == "toggle" then
local cb = poolCheck(page, f.name, f.set, f.get)
cb:SetPoint("TOPLEFT", x, y)
return 24
elseif f.type == "space" then
local line = 24
return f.useHeight and (f.height or 1) * line or line
elseif f.type == "input" then
local label = poolLabel(page, f.name)
label:SetPoint("TOPLEFT", x, y)
local e = poolEditBox(page, w, f.set)
local v = f.get()
e:SetText(v ~= nil and tostring(v) or "")
e:SetPoint("TOPLEFT", x, y - lead)
return lead + 28
elseif f.type == "multiline" then
local label = poolLabel(page, f.name)
label:SetPoint("TOPLEFT", x, y)
-- Wants far more width than a normal field's capped column; size to the
-- page rather than the passed `w`. Commits on focus lost, not per
-- keystroke -- a custom-trigger `set` recompiles the aura, and Enter is a
-- newline in a multi-line box, so mid-typing commits are wrong here.
local mw = (page:GetWidth() or 400) - x - 16
if mw < 120 then mw = 120 end
local mh = f.height or 150
local box = poolMultiline(page, mw, mh, f.get() or "", f.set)
box:SetPoint("TOPLEFT", x, y - lead)
return lead + mh + 8
elseif f.type == "description" then
-- Text only, no control: `name` is the whole body. Sized to the page
-- rather than the capped column, since it is prose and wraps.
local dw = f.half and w or ((page:GetWidth() or 400) - x - 16)
if dw < 120 then dw = 120 end
local fs = poolDescription(page, f.name, dw)
fs:SetPoint("TOPLEFT", x, y)
return (fs:GetHeight() or 12) + 8
elseif f.type == "code" then
local label = poolLabel(page, f.name)
label:SetPoint("TOPLEFT", x, y)
-- Same page-width sizing as `multiline`: code wants far more room than a
-- normal field's capped column.
local mw = (page:GetWidth() or 400) - x - 16
if mw < 120 then mw = 120 end
local mh = f.height or 150
local box = poolCode(page, f, mw, mh)
-- The lead is deeper here than a plain label needs: it also has to clear
-- the widget's own Reset button, which sits above the box's top-right
-- corner.
box:SetPoint("TOPLEFT", x, y - lead)
-- The label/Reset row, then the box, then the widget's own error line
-- (14) -- which is always allotted, so the layout below doesn't shift as
-- errors come and go while typing.
return lead + mh + 8 + 14
elseif f.type == "spell" or f.type == "item" or f.type == "talent" or f.type == "icon" or f.type == "texture" then
local label = poolLabel(page, f.name)
label:SetPoint("TOPLEFT", x, y)
local icon = poolPreviewIcon(page)
icon:SetPoint("TOPLEFT", x, y - lead)
-- `spell`/`item` store what the user typed and preview whatever it
-- resolves to; `icon` resolves at commit instead and stores the texture
-- path itself, so the region can SetTexture it blindly.
local function resolve(v)
if f.type == "spell" then
local id = WA.ResolveSpellID(v)
if not id then return nil end
local _, _, ic = GetSpellInfo(id)
return ic
elseif f.type == "item" then
local id = WA.ResolveItemID(v)
if not id then return nil end
-- C_Item.GetItemInfo's 18-value tuple, not the stock global's short
-- one: only the modern shape has the texture in slot 10.
if not (C_Item and C_Item.GetItemInfo) then return nil end
local _, _, _, _, _, _, _, _, _, ic = C_Item.GetItemInfo(id)
return ic
elseif f.type == "talent" then
return f.resolve and f.resolve(v) or nil
end
local id = WA.ResolveSpellID(v)
if id then local _, _, ic = GetSpellInfo(id); return ic end
if v and v ~= "" then return v end
return nil
end
-- An `icon` field additionally gets a Browse button opening the picker;
-- typing a path by hand still works, it just stops being the only way.
local browsable = f.type == "icon" or f.type == "texture"
local browseW = browsable and 62 or 0
local e = poolEditBox(page, w - 24 - browseW, function(v)
local path = resolve(v)
if browsable then f.set(path or "") else f.set(v) end
icon:SetTexture(path or QUESTION_ICON)
if WA.RefreshList then WA.RefreshList() end
end)
-- Only an item field takes a shift-clicked link; a spell, talent, or icon field has
-- nothing to do with one.
e.acceptsLinks = (f.type == "item")
local v = f.get()
e:SetText(v ~= nil and tostring(v) or "")
e:SetPoint("TOPLEFT", x + 24, y - lead)
if browsable then
icon:SetTexture(WA.DrawableTexture(v) or QUESTION_ICON)
local b = poolButton(page, "Browse", browseW - 4, function()
local picker = f.type == "texture" and W.OpenTexturePicker or W.OpenIconPicker
picker(f.get(), function(path)
f.set(path or "")
if WA.RefreshList then WA.RefreshList() end
if WA.RefreshOptions then WA.RefreshOptions() end
end)
end)
b:SetPoint("TOPLEFT", x + 24 + (w - 24 - browseW) + 4, y - lead)
else
icon:SetTexture(resolve(v) or QUESTION_ICON)
end
return lead + 28
elseif f.type == "namelist" then
local label = poolLabel(page, f.name)
label:SetPoint("TOPLEFT", x, y)
local n = table.getn(f.get())
local visibleRows = n < 2 and 2 or (n > 5 and 5 or n)
local rightInset = (page:GetWidth() or 400) - (x + w)
local frame = poolListEditor(page, f, x, y - lead, rightInset, visibleRows)
return lead + frame.editor.height + 6
elseif f.type == "range" then
local s = acquire(page, "spin", function()
-- The bind table *is* the widget's spec: NewSpinBox reads label/min/
-- max/step/onChange out of it at call time, so rebinding is assignment.
local bind
bind = {
min = 0, max = 1, step = 1, width = 220,
textureDir = W.LIBWIDGETS_TEXTURES,
onChange = function(v) if bind.set then bind.set(v) end end,
}
local sp = LibWidgets.NewSpinBox(page, bind)
sp.bind = bind
return sp
end)
-- Unbound across the rebind, because two things here can move the value:
-- clearing a box that still holds focus from the edit which caused this
-- repaint commits it, and a narrowed range clamps the carried-over number.
-- Either would write into the field being painted rather than the one the
-- user was actually editing.
s.bind.set = nil
s.edit:ClearFocus()
s.bind.label, s.bind.fmt, s.bind.decimals = f.name, f.fmt, f.decimals
s.bind.min, s.bind.max, s.bind.step = f.min, f.max, f.step
s.setWidth(w)
s.setValue(f.get())
s.bind.set = f.set
s:SetPoint("TOPLEFT", x, y)
return 38
elseif f.type == "disclosure" then
-- A settings fold: a gear plus a one-line label, the whole line clickable.
-- Deliberately not a `header` -- a header titles a region of the tab, this
-- hides settings that get set once and then only get in the way, so it
-- reads as a control rather than as a divider.
local btn = poolIconButton(page, GEAR_ICON, f.onToggle or function() end)
btn:SetPoint("TOPLEFT", x, y)
if f.collapsed then btn.icon:SetVertexColor(0.6, 0.6, 0.6) end
-- The summary says what the folded rows hold, so the closed state still
-- carries the settings rather than merely naming them.
local text = f.name or ""
if f.summary and f.summary ~= "" then text = text .. "|cff9d9d9d: " .. f.summary .. "|r" end
local label = poolLabel(page, text)
label:SetPoint("TOPLEFT", x + 20, y - 2)
local hit = poolHitArea(page, f.onToggle or function() end)
hit:SetPoint("TOPLEFT", x + 20, y)
hit:SetPoint("TOPRIGHT", page, "TOPLEFT", x + 24 + (label:GetStringWidth() or 0), y)
return 22
elseif f.type == "select" then
local label = poolLabel(page, f.name)
label:SetPoint("TOPLEFT", x, y)
local dw = w < 160 and w or 160
local actionCount = table.getn(f.actions or {})
if actionCount > 0 then
local actionW = actionCount * 16 + (actionCount - 1) * 6
local available = w - actionW - 6
if available < 90 then available = 90 end
dw = available < 160 and available or 160
end
local d = poolDropdown(page, dw, f.values, f.labels, f.set, f.get, f.swatches, f.previews, f.onPreview)
d:SetPoint("TOPLEFT", x, y - lead)
for i = 1, actionCount do
local action = f.actions[i]
local button = poolActionButton(page, action)
button:SetPoint("TOPLEFT", x + dw + 6 + (i - 1) * 22, y - lead + 2)
end
return lead + 28
elseif f.type == "opnumber" then
local label = poolLabel(page, f.name)
label:SetPoint("TOPLEFT", x, y)
local op = poolDropdown(page, 52, W.OPERATORS, nil, f.setOp, f.getOp)
op:SetPoint("TOPLEFT", x, y - lead)
local e = poolEditBox(page, 60, function(v) f.setVal(tonumber(v)) end)
local v = f.getVal()
e:SetText(v ~= nil and tostring(v) or "")
e:SetPoint("TOPLEFT", x + 58, y - lead)
return lead + 28
elseif f.type == "color" then
local label = poolLabel(page, f.name)
label:SetPoint("TOPLEFT", x, y - 3)
local sw = poolColor(page, f.get, f.set)
sw:SetPoint("TOPLEFT", x + 100, y)
return 26
elseif f.type == "button" then
local b = poolButton(page, f.name, f.width or w, f.onClick)
b:SetPoint("TOPLEFT", x, y)
return 28
elseif f.type == "menu" then
local d = poolMenuButton(page, f.width or w, f.name, f.values, f.labels, f.onSelect)
d:SetPoint("TOPLEFT", x, y)
return 28
elseif f.type == "anchorgrid" then
local label = poolLabel(page, f.name)
label:SetPoint("TOPLEFT", x, y)
local gw = f.width or w
local grid = poolAnchorGrid(page, f, gw)
grid:SetPoint("TOPLEFT", x, y - lead)
return lead + (f.height or 50) + 8
elseif f.type == "anchorlayout" then
local grid = f.grid
local gridW = grid.width or 100
local gridH = grid.height or 50
local anchor = poolLabel(page, grid.name)
anchor:SetPoint("TOPLEFT", x, y)
local anchorGrid = poolAnchorGrid(page, grid, gridW)
anchorGrid:SetPoint("TOPLEFT", x, y - lead)
local sideX = x + gridW + 12
local sideW = w - gridW - 12
if sideW < 90 then sideW = 90 end
local sideY = y
local sideHeight = 0
for i = 1, table.getn(f.sideFields or {}) do
local used = placeField(page, f.sideFields[i], sideX, sideY, sideW)
sideY = sideY - used
sideHeight = sideHeight + used
end
local gridHeight = lead + gridH + 8
return gridHeight > sideHeight and gridHeight or sideHeight
end
return 0
end
-- (Re)paints `page` from `fields`, reusing the widgets already on it (see the
-- widget pool above). Fields flagged `half` pack two-per-row; columns size to
-- the page's current width so the layout follows a resized options window.
function W.BuildOptions(page, fields)
page.widgetPools = page.widgetPools or {}
page.widgetUsed = page.widgetUsed or {}
-- A NewDropButton popup is parented to the window, not to its button or this
-- page, so the sweep below can't take it down: an open menu would survive the
-- repaint and float over the new controls. Closing it here rather than
-- relying on the caller is what lets the invariant below hold for *every*
-- widget this page owns. It also drops edit focus, which has to happen
-- before anything below re-seeds a pooled box -- a commit-on-blur editor
-- reached by the seed first would have the user's unsaved text overwritten
-- by the stored value and only then be asked to commit it.
LibWidgets.CloseAllMenus()
-- Everything on the page goes down before anything comes back up, and
-- `acquire` re-Shows only what this paint actually uses. Hiding up front
-- rather than sweeping the unused tail at the end is what makes "a control
-- from the previous tab is still on screen" structurally impossible: the
-- sweep only holds if the paint runs to completion, so any error partway
-- through (or an early return added later) stranded whatever the previous
-- paint had put there. This ordering has no such precondition.
for kind, pool in pairs(page.widgetPools) do
page.widgetUsed[kind] = 0
for i = 1, table.getn(pool) do pool[i]:Hide() end
end
local avail = page:GetWidth()
if not avail or avail < 120 then avail = 400 end
local gap = 12
local colW = math.floor((avail - 16 - gap) / 2)
if colW < 90 then colW = 90 end
local leftX, rightX = 8, 8 + colW + gap
local fullW = avail - 16
if fullW > 240 then fullW = 240 end
local y = -8
-- A `half` field waits here for the partner it shares its row with, since
-- where it goes depends on that partner's shape. A header, a full-width
-- field, or the end of the list flushes it into the left column alone.
local pending, pendingY
local function flushPending()
if not pending then return end
y = pendingY - placeField(page, pending, leftX, pendingY, colW - 8)
pending = nil
end
for i = 1, table.getn(fields) do
local f = fields[i]
if f.type == "header" then
flushPending()
y = y - 10
-- Centered gold label flanked by horizontal rules (the WeakAuras
-- section-divider look) -- plain size-differentiated text wasn't
-- separating areas clearly enough.
local h = poolHeaderLabel(page, f.name)
local headerIndent = (f.indent or 0) * OPTIONS_INDENT_W
h:SetPoint("TOP", page, "TOPLEFT", avail / 2 + headerIndent, y)
-- Header actions occupy the right edge in descriptor order; placing them
-- backwards keeps the first action leftmost.
local leftEdge, rightEdge = 8 + headerIndent, avail - 8
if f.onDelete then
local del = poolDeleteButton(page, f.onDelete)
del:SetPoint("TOPRIGHT", page, "TOPLEFT", rightEdge, y + 2)
rightEdge = rightEdge - 16 - 6
end
for actionIndex = table.getn(f.actions or {}), 1, -1 do
local action = f.actions[actionIndex]
local button = poolActionButton(page, action)
button:SetPoint("TOPRIGHT", page, "TOPLEFT", rightEdge, y + 2)
rightEdge = rightEdge - 16 - 6
end
if f.collapsed ~= nil then
-- The arrow points the way the section will move on click: down to
-- unfold a collapsed one, up to fold an open one.
local arrow = poolIconButton(page,
W.LIBWIDGETS_TEXTURES .. (f.collapsed and "down" or "up"),
f.onToggle or function() end)
arrow:SetPoint("TOPLEFT", 8 + headerIndent, y + 2)
leftEdge = 8 + headerIndent + 16 + 6
end
-- The whole title line toggles too, not just the small arrow. It's a
-- bare mouse-enabled frame (no textures of its own) laid over the
-- label, and it stops at rightEdge so it can never sit on top of the
-- delete button and swallow its clicks.
if f.collapsed ~= nil then
local hit = poolHitArea(page, f.onToggle or function() end)
hit:SetPoint("TOPLEFT", leftEdge, y + 2)
hit:SetPoint("TOPRIGHT", page, "TOPLEFT", rightEdge, y + 2)
end
local tw = h:GetStringWidth() or 0
local midY, cx, pad = y - 6, avail / 2, 8
-- Only draw the flanking rules when the label leaves room for them;
-- otherwise the texture ends would cross and render inverted.
if cx - tw / 2 - pad > leftEdge + 4 then
local ll = poolRule(page)
ll:SetPoint("LEFT", page, "TOPLEFT", leftEdge, midY)
ll:SetPoint("RIGHT", page, "TOPLEFT", cx - tw / 2 - pad, midY)
local rl = poolRule(page)
rl:SetPoint("LEFT", page, "TOPLEFT", cx + tw / 2 + pad, midY)
rl:SetPoint("RIGHT", page, "TOPLEFT", rightEdge, midY)
end
y = y - 18
elseif f.half then
if not pending then
pending, pendingY = f, y
else
-- Both controls hang from the deeper of the two caption lines, so
-- a one-line toggle lands beside the control of the labelled field
-- next to it rather than beside that field's caption. The row is
-- then as tall as the taller of the two bodies under that line.
local leadL, leadR = fieldLead(pending), fieldLead(f)
local top = leadL > leadR and leadL or leadR
local lh = (top - leadL) + placeField(page, pending, leftX, pendingY - (top - leadL), colW - 8)
local rh = (top - leadR) + placeField(page, f, rightX, pendingY - (top - leadR), colW - 8)
y = pendingY - (lh > rh and lh or rh)
pending = nil
end
else
flushPending()
y = y - placeField(page, f, 8, y, fullW)
end
end
flushPending()
-- Total laid-out height (y runs negative from the top), so a scroll-child
-- container can size itself to the content -- see OptionsFrame.lua's content
-- scroll frame.
page.contentHeight = -y + 8
end
-- ---------------------------------------------------------------------------
-- Context menu
--
-- W.ContextMenu(parent) -> a frame with Open(items, anchor) and Close(). The
-- item list is passed to every Open, so one menu instance serves any number of
-- differently-shaped menus:
-- { text = "Duplicate", onClick = function() end }
-- { text = "Copy settings", submenu = { ...items... } } -- one level only
-- { separator = true }
-- { text = "Delete", disabled = true } -- greyed, inert
-- { text = "Delete", confirm = true, onClick = ... } -- two-click morph
-- Item buttons come from the same per-kind pool BuildOptions uses, so contents
-- that change per opening cost no new frames after the first paint.
-- ---------------------------------------------------------------------------
local MENU_ITEM_H = 16
local MENU_PAD = 3
local MENU_MIN_W, MENU_MAX_W = 120, 260
local paintMenu
local function menuItemClicked(b)
local item = b.item
if not item or item.disabled then return end
-- A confirm item stays open across its first click: a menu that closed on
-- every click could not show an armed state at all.
if item.confirm and not b.confirming then
b.confirming = true
b.label:SetText("Confirm?")
C_Timer.After(3, function()
-- Buttons are pooled and rebound: only revert one still holding the
-- item that armed it.
if b.confirming and b.item == item then
b.confirming = nil
b.label:SetText(item.text or "")
end
end)
return
end
b.confirming = nil
b.menu.Root().Close()
if item.onClick then item.onClick() end
end
local function menuItemEntered(b)
local sub = b.menu.sub
if not sub then return end
-- Entering any item takes down whatever submenu the previous one opened, so
-- at most one is ever up.
sub:Hide()
local item = b.item
if not item or item.disabled or not item.submenu then return end
paintMenu(sub, item.submenu)
sub:ClearAllPoints()
local right = b:GetRight()
local screenW = UIParent:GetWidth()
if not screenW or screenW <= 0 then screenW = GetScreenWidth() end
if right and right + (sub:GetWidth() or 0) > screenW then
sub:SetPoint("TOPRIGHT", b, "TOPLEFT", -2, MENU_PAD)
else
sub:SetPoint("TOPLEFT", b, "TOPRIGHT", 2, MENU_PAD)
end
sub:Show()
end
local function newMenuItem(f)
local b = CreateFrame("Button", nil, f)
b:SetHeight(MENU_ITEM_H)
b.menu = f
local fs = b:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
fs:SetPoint("LEFT", 4, 0)
fs:SetJustifyH("LEFT")
b.label = fs
local arrow = b:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
arrow:SetPoint("RIGHT", -4, 0)
arrow:SetText(">")
arrow:Hide()
b.arrow = arrow
local hl = b:CreateTexture(nil, "HIGHLIGHT")
hl:SetAllPoints(b)
hl:SetTexture(0.3, 0.3, 0.8, 0.4)
b.hl = hl
b:SetScript("OnClick", function() menuItemClicked(b) end)
b:SetScript("OnEnter", function() menuItemEntered(b) end)
return b
end
function paintMenu(f, items)
-- Same hide-first ordering BuildOptions uses: everything goes down before
-- anything comes back up, so a paint that errors partway cannot leave an
-- item from the previous opening on screen.
for kind, pool in pairs(f.widgetPools) do
f.widgetUsed[kind] = 0
for i = 1, table.getn(pool) do pool[i]:Hide() end
end
local width = MENU_MIN_W
local y = -MENU_PAD
for i = 1, table.getn(items) do
local item = items[i]
if item.separator then
local t = acquire(f, "menusep", function()
local tex = f:CreateTexture(nil, "ARTWORK")
tex:SetHeight(1)
tex:SetTexture(0.4, 0.4, 0.4, 0.8)
return tex
end)
t:SetPoint("TOPLEFT", f, "TOPLEFT", MENU_PAD + 2, y - 3)
t:SetPoint("TOPRIGHT", f, "TOPRIGHT", -(MENU_PAD + 2), y - 3)
y = y - 7
else
local b = acquire(f, "menuitem", function() return newMenuItem(f) end)
b:SetPoint("TOPLEFT", f, "TOPLEFT", MENU_PAD, y)
b:SetPoint("TOPRIGHT", f, "TOPRIGHT", -MENU_PAD, y)
b.item = item
-- Disarm on reuse, or a pooled button armed by the last opening would
-- commit that click against whatever item it holds in this one.
b.confirming = nil
b.label:SetText(item.text or "")
if item.disabled then
b.label:SetTextColor(0.5, 0.5, 0.5)
b.hl:SetTexture(0, 0, 0, 0)
else
b.label:SetTextColor(1, 1, 1)
b.hl:SetTexture(0.3, 0.3, 0.8, 0.4)
end
if item.submenu then b.arrow:Show() else b.arrow:Hide() end
local w = (b.label:GetStringWidth() or 0) + 2 * MENU_PAD + 12
if item.submenu then w = w + 14 end
if w > width then width = w end
y = y - MENU_ITEM_H
end
end
if width > MENU_MAX_W then width = MENU_MAX_W end
f:SetWidth(width)
f:SetHeight(-y + MENU_PAD)
end
local function newMenuFrame(parent)
local f = CreateFrame("Frame", nil, parent)
f:SetBackdrop(W.EDITBOX_BACKDROP)
f:SetBackdropColor(0, 0, 0, 0.95)
f:SetBackdropBorderColor(0.4, 0.4, 0.4, 0.9)
f:SetFrameStrata("FULLSCREEN_DIALOG")
f:SetToplevel(true)
-- Mouse-enabled so a click on the menu's own padding is swallowed here
-- rather than falling through to the click-away catcher underneath.
f:EnableMouse(true)
f:Hide()
f.widgetPools, f.widgetUsed = {}, {}
return f
end
-- Places the menu at the cursor, flipping left/up against whichever screen edge
-- it would otherwise cross. `anchor` is the fallback for a client that gives no
-- cursor position, opening to the right of the frame that was clicked.
local function placeMenu(f, anchor)
local x, y = GetCursorPosition()
local scale = UIParent:GetEffectiveScale()
f:ClearAllPoints()
if not x or not scale or scale == 0 then
f:SetPoint("TOPLEFT", anchor or UIParent, "TOPRIGHT", 4, 0)
return
end
x, y = x / scale, y / scale
local screenW = UIParent:GetWidth()
if not screenW or screenW <= 0 then screenW = GetScreenWidth() end
local horiz = (x + (f:GetWidth() or 0) > screenW) and "RIGHT" or "LEFT"
local vert = (y - (f:GetHeight() or 0) < 0) and "BOTTOM" or "TOP"
f:SetPoint(vert .. horiz, UIParent, "BOTTOMLEFT", x, y)
end
function W.ContextMenu(parent)
local f = newMenuFrame(parent)
f.sub = newMenuFrame(f)
f.sub:SetFrameLevel(f:GetFrameLevel() + 5)
f.Root = function() return f end
f.sub.Root = f.Root
-- Click-outside dismissal. LibWidgets.CloseAllMenus only reaches clicks that
-- land on a LibWidgets control, so this needs its own full-screen catcher one
-- strata below the menu to also close on a click into the aura list, the tab
-- pane or the world.
local catcher = CreateFrame("Frame", nil, UIParent)
catcher:SetAllPoints(UIParent)
catcher:EnableMouse(true)
catcher:SetFrameStrata("FULLSCREEN")
catcher:Hide()
catcher:SetScript("OnMouseDown", function() f.Close() end)
f.catcher = catcher
f.Close = function()
f.sub:Hide()
f:Hide()
catcher:Hide()
end
f.Open = function(items, anchor)
-- A drop-button popup and a context menu must never be up at once.
LibWidgets.CloseAllMenus()
f.sub:Hide()
paintMenu(f, items)
placeMenu(f, anchor)
catcher:Show()
f:Show()
end
-- The catcher is a UIParent child, so nothing takes it down when the menu's
-- own parent hides -- and a stranded catcher is a full-screen invisible
-- mouse blocker over the whole UI.
f:SetScript("OnHide", function()
f.sub:Hide()
catcher:Hide()
end)
return f
end