Files
pfQuest_xpGuide/Theme.lua
T
pfQuest xpGuideandClaude Sonnet 5.5 ef2f4f34b3 pfQuest xpGuide 1.0.0
A leveling guide for WoW 1.12 players of pfQuest, based on Easy Route by stealthzi (MIT).
See README.md and CHANGES.md.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XfR1apt9f3R7SxBKB2FF2D
2026-11-16 14:47:43 +08:00

457 lines
18 KiB
Lua

-- pfQuest xpGuide: the look. With pfUI loaded, every window takes pfUI's theme the way OctoPad does: pfUI's rounded backdrop
-- in the colours of your pfUI profile (background, border), pfUI's font, a cyan accent (#33ffcc), flat buttons whose
-- border lights up in the accent on mouse-over and that turn accent when selected, small accent headers with a thin
-- line, pfUI's own checkboxes, input boxes and scroll bars, a flat "x" close button, and icons cropped inside a rounded
-- border. Without pfUI (or with "Use pfUI's look" unticked in the settings) nothing here runs and the windows keep
-- their own look.
--
-- How it is used: a window calls ER.Skin.Window(frame, alpha) right after giving the frame its backdrop, and
-- ER.Skin.Tree(frame) once its contents are built. Tree walks the frame and everything in it and skins what it
-- recognises by its textures (Blizzard's panel button, close button and checkbox, Interface\Icons icons, the quest
-- title highlight) and by type (input boxes, scroll frames, font strings). Every step is safe to run twice.
local ER = pfQuest_xpGuide
ER.Skin = ER.Skin or {}
local K = ER.Skin
local WHITE8 = "Interface\\Buttons\\WHITE8X8"
local FLAT = { bgFile = WHITE8, edgeFile = WHITE8, edgeSize = 1, insets = { left = 1, right = 1, top = 1, bottom = 1 } }
-- On when pfUI is there with its backdrop API and you have not turned the look off. Read when a window is built.
function K.On()
if ER.db and ER.db.pfuiThemeOff then return false end
return (pfUI and pfUI.api and pfUI.api.CreateBackdrop and pfUI_config and pfUI_config.appearance) and true or false
end
function K.Available()
return (pfUI and pfUI.api and pfUI.api.CreateBackdrop and pfUI_config and pfUI_config.appearance) and true or false
end
function K.Font()
return (pfUI and pfUI.font_default) or "Fonts\\FRIZQT__.TTF"
end
local function ParseColor(str, d)
if type(str) == "string" then
local _, _, r, g, b, a = string.find(str, "([%d%.]+)%s*,%s*([%d%.]+)%s*,%s*([%d%.]+)%s*,?%s*([%d%.]*)")
if r then return { tonumber(r), tonumber(g), tonumber(b), tonumber(a) or 1 } end
end
return d
end
-- The colours, as OctoPad works them out: pfUI's background and border, a lighter fill for buttons, a darker sidebar.
function K.Theme()
local t = { bg = { .05, .06, .08, .92 }, bd = { .25, .27, .3, 1 }, ac = { .2, 1, .8, 1 } }
local ap = pfUI_config and pfUI_config.appearance
if ap and ap.border then
t.bg = ParseColor(ap.border.background, t.bg)
t.bd = ParseColor(ap.border.color, t.bd)
if t.bg[4] > .95 then t.bg[4] = .95 end
end
t.fill = { math.min(1, t.bg[1] + .07), math.min(1, t.bg[2] + .07), math.min(1, t.bg[3] + .07), 1 }
t.side = { math.max(0, t.bg[1] - .02), math.max(0, t.bg[2] - .02), math.max(0, t.bg[3] - .02), 1 }
return t
end
K.ACCENT = "|cff33ffcc"
local function Safe(fn, a, b, c, d)
local ok, r = pcall(fn, a, b, c, d)
if ok then return r end
return nil
end
-- The frame that carries the colours: pfUI's backdrop frame when pfUI drew one, else the frame itself.
function K.BD(f)
if f.erRound and f.backdrop then return f.backdrop end
return f
end
-- A gold border (the step box, the tips box) means "this one": under the theme that is the accent.
local function Goldish(r, g, b)
return r and g and b and r > .7 and g > .45 and g < .8 and b < .45
end
-- pfUI's rounded backdrop on a frame. The frame's own backdrop goes; later colour calls are sent on to pfUI's backdrop
-- (border colours, with gold turned into the accent) or kept from changing pfUI's background (fill colours).
function K.Window(f, alpha)
if not f or not K.On() then return false end
if f.erRound ~= nil then return f.erRound end
local wasGold
if f.GetBackdropBorderColor then
local ok, r, g, b = pcall(f.GetBackdropBorderColor, f)
wasGold = ok and Goldish(r, g, b)
end
local ok = pcall(pfUI.api.CreateBackdrop, f, nil, nil, alpha or .9)
f.erRound = (ok and f.backdrop) and true or false
if not f.erRound then return false end
pcall(f.SetBackdrop, f, nil)
local t = K.Theme()
f.SetBackdrop = function() end
f.SetBackdropColor = function() end
f.SetBackdropBorderColor = function(self, r, g, b, a)
if Goldish(r, g, b) then r, g, b, a = t.ac[1], t.ac[2], t.ac[3], 1 end
if self.backdrop then self.backdrop:SetBackdropBorderColor(r, g, b, a or 1) end
end
if wasGold then f.backdrop:SetBackdropBorderColor(t.ac[1], t.ac[2], t.ac[3], 1) end
return true
end
-- pfUI's font on a font string, keeping its size and outline.
function K.FontOn(fs)
if not fs or fs.erFont or not fs.GetFont then return end
local ok, _, size, flags = pcall(fs.GetFont, fs)
if ok and size and size > 0 then
pcall(fs.SetFont, fs, K.Font(), size, flags or "")
fs.erFont = true
end
end
local function Chain(f, script, after)
local old = f:GetScript(script)
f:SetScript(script, function()
if old then old() end
after(this)
end)
end
-- Selected / not selected, as OctoPad's SetSel: accent border, accent-tinted fill and accent text when selected.
function K.Select(b, on)
local t = K.Theme()
local g = K.BD(b)
b.erSel = on
if on then
g:SetBackdropColor(t.fill[1] * .5 + t.ac[1] * .12, t.fill[2] * .5 + t.ac[2] * .12, t.fill[3] * .5 + t.ac[3] * .12, 1)
g:SetBackdropBorderColor(t.ac[1], t.ac[2], t.ac[3], 1)
if b.erText then b.erText:SetTextColor(t.ac[1], t.ac[2], t.ac[3]) end
else
g:SetBackdropColor(t.fill[1], t.fill[2], t.fill[3], 1)
g:SetBackdropBorderColor(t.bd[1], t.bd[2], t.bd[3], 1)
if b.erText then b.erText:SetTextColor(.9, .9, .9) end
end
end
local function ButtonText(b)
local fs = b.GetFontString and Safe(function() return b:GetFontString() end)
if not fs and b.GetName and b:GetName() then fs = getglobal(b:GetName() .. "Text") end
return fs
end
-- OctoPad's flat button: rounded fill, theme border, accent border on mouse-over, accent when locked (selected).
function K.Flat(b)
if not b or b.erFlat or not K.On() then return end
b.erFlat = true
pcall(b.SetNormalTexture, b, "")
pcall(b.SetPushedTexture, b, "")
pcall(b.SetHighlightTexture, b, "")
pcall(b.SetDisabledTexture, b, "")
if not K.Window(b, 1) then
b.SetBackdrop = nil
b:SetBackdrop(FLAT)
end
b.erText = ButtonText(b)
if b.erText then K.FontOn(b.erText) end
K.Select(b, false)
Chain(b, "OnEnter", function(self)
local t = K.Theme()
K.BD(self):SetBackdropBorderColor(t.ac[1], t.ac[2], t.ac[3], 1)
end)
Chain(b, "OnLeave", function(self) K.Select(self, self.erSel) end)
b.LockHighlight = function(self) K.Select(self, true) end
b.UnlockHighlight = function(self) K.Select(self, false) end
end
-- The close button: OctoPad's flat "x" in the top right corner.
-- Where a corner or edge anchor sits from a frame's centre, in half widths and heights.
local CENTRE_FROM = { TOPLEFT = { 1, -1 }, TOP = { 0, -1 }, TOPRIGHT = { -1, -1 }, LEFT = { 1, 0 }, CENTER = { 0, 0 },
RIGHT = { -1, 0 }, BOTTOMLEFT = { 1, 1 }, BOTTOM = { 0, 1 }, BOTTOMRIGHT = { -1, 1 } }
function K.Close(b)
if not b or b.erFlat or not K.On() then return end
local parent = b:GetParent()
-- The button keeps its place: the window put it where it belongs (the step window's sits above the step box, next to the
-- "Step 3 of 20" tab), so the smaller flat button is centred where the old one's middle was.
local point, rel, relPoint, x, y = b:GetPoint(1)
local off = point and CENTRE_FROM[point]
local w, h = b:GetWidth() or 32, b:GetHeight() or 32
b:SetWidth(20)
b:SetHeight(20)
if off then
b:ClearAllPoints()
b:SetPoint("CENTER", rel or parent, relPoint or point, (x or 0) + off[1] * w / 2, (y or 0) + off[2] * h / 2)
elseif parent then
b:ClearAllPoints()
b:SetPoint("TOPRIGHT", parent, "TOPRIGHT", -8, -8)
end
if not ButtonText(b) then
local fs = b:CreateFontString(nil, "OVERLAY")
fs:SetFont(K.Font(), 11)
fs:SetPoint("CENTER", b, "CENTER", 0, 1)
b.erCloseText = fs
b.GetFontString = function() return fs end
end
K.Flat(b)
if b.erText then b.erText:SetText("x") end
end
function K.Check(c)
if not c or c.erCheck or not K.On() then return end
c.erCheck = true
if pfUI.api.SkinCheckbox then pcall(pfUI.api.SkinCheckbox, c, 18) end
if c.GetName and c:GetName() then K.FontOn(getglobal(c:GetName() .. "Text")) end
end
function K.Input(e)
if not e or e.erInput or not K.On() then return end
e.erInput = true
if pfUI.api.StripTextures then pcall(pfUI.api.StripTextures, e) end
K.Window(e, 1)
if e.GetFont then
local _, size = Safe(function() return e:GetFont() end)
pcall(e.SetFont, e, K.Font(), size or 12, "")
end
end
function K.Scroll(sf)
if not sf or sf.erScroll or not K.On() then return end
sf.erScroll = true
local name = sf.GetName and sf:GetName()
local bar = name and getglobal(name .. "ScrollBar")
if bar and pfUI.api.SkinScrollbar then pcall(pfUI.api.SkinScrollbar, bar) end
end
-- An icon button (the gear, the book): cropped icon inside a rounded border that lights up on mouse-over.
function K.IconButton(b)
if not b or b.erIcon or not K.On() then return end
b.erIcon = true
local n = b.GetNormalTexture and b:GetNormalTexture()
if n then
n:SetTexCoord(.07, .93, .07, .93)
n:ClearAllPoints()
n:SetPoint("TOPLEFT", b, "TOPLEFT", 1, -1)
n:SetPoint("BOTTOMRIGHT", b, "BOTTOMRIGHT", -1, 1)
end
pcall(b.SetHighlightTexture, b, "")
pcall(b.SetPushedTexture, b, "")
if K.Window(b, 1) then
local t = K.Theme()
K.BD(b):SetBackdropBorderColor(t.bd[1], t.bd[2], t.bd[3], 1)
Chain(b, "OnEnter", function(self) local th = K.Theme() K.BD(self):SetBackdropBorderColor(th.ac[1], th.ac[2], th.ac[3], 1) end)
Chain(b, "OnLeave", function(self) local th = K.Theme() K.BD(self):SetBackdropBorderColor(th.bd[1], th.bd[2], th.bd[3], 1) end)
end
end
-- OctoPad's header: small upper-case accent text with a thin accent line under it.
function K.Header(fs, rule)
if not K.On() then return end
local t = K.Theme()
if fs then
local text = fs:GetText()
if text then fs:SetText(string.upper(string.gsub(text, "|c%x%x%x%x%x%x%x%x", ""))) end
pcall(fs.SetFont, fs, K.Font(), 10, "")
fs:SetTextColor(t.ac[1], t.ac[2], t.ac[3])
fs.erFont = true
end
if rule then
rule:SetTexture(WHITE8)
rule:SetVertexColor(t.ac[1], t.ac[2], t.ac[3], .35)
end
end
-- A window title the OctoPad way: the accent name in pfUI's font, outlined.
function K.Title(fs, size)
if not fs or not K.On() then return end
pcall(fs.SetFont, fs, K.Font(), size or 14, "OUTLINE")
fs.erFont = true
end
local function Lower(s) return type(s) == "string" and string.lower(s) or "" end
local function Has(s, part) return string.find(s, part, 1, true) ~= nil end
local function SkinRegion(r)
local kind = r.GetObjectType and r:GetObjectType()
if kind == "FontString" then
K.FontOn(r)
elseif kind == "Texture" and not r.erTex then
local path = Lower(r.GetTexture and r:GetTexture())
if Has(path, "ui-questtitlehighlight") or Has(path, "buttonhilight-square") then
-- the row highlight: a soft accent tint, as OctoPad's focus tint
local t = K.Theme()
r:SetTexture(WHITE8)
r:SetVertexColor(t.ac[1], t.ac[2], t.ac[3], .16)
r.erTex = true
elseif Has(path, "interface\\icons\\") then
r:SetTexCoord(.07, .93, .07, .93)
r.erTex = true
end
end
end
local function NormalPath(f)
local n = f.GetNormalTexture and Safe(function() return f:GetNormalTexture() end)
return Lower(n and n.GetTexture and n:GetTexture())
end
local function Walk(f, depth)
if not f or depth > 12 then return end
local kind = f.GetObjectType and f:GetObjectType()
if kind == "Button" or kind == "CheckButton" then
local path = NormalPath(f)
if Has(path, "ui-panel-minimizebutton") then K.Close(f)
elseif Has(path, "ui-panel-button") then K.Flat(f)
elseif Has(path, "ui-checkbox") then K.Check(f)
elseif Has(path, "interface\\icons\\") then K.IconButton(f) end
elseif kind == "EditBox" then
local name = f.GetName and f:GetName()
if name and getglobal(name .. "Left") then K.Input(f) end
K.FontOn(f)
elseif kind == "ScrollFrame" then
K.Scroll(f)
end
if f.GetRegions then
local regions = { f:GetRegions() }
for _, r in ipairs(regions) do SkinRegion(r) end
end
if f.GetChildren then
local kids = { f:GetChildren() }
for _, c in ipairs(kids) do Walk(c, depth + 1) end
end
end
-- Skins a window and everything in it now.
function K.Tree(f)
if not f or not K.On() then return end
pcall(Walk, f, 0)
end
-- The top-level windows. Each is skinned the moment it opens and once a second besides, for rows and buttons made after
-- it was built (a window's own OnShow is never touched). Everything already skinned is passed over quickly.
K.windows = {}
function K.Register(f)
if not f or f.erRegistered then return end
f.erRegistered = true
table.insert(K.windows, f)
end
local TOP = { UIParent = true, Minimap = true, QuestLogFrame = true }
local rawWindow = K.Window
K.Window = function(f, alpha)
local ok = rawWindow(f, alpha)
if ok then
-- register the window this frame belongs to: its highest ancestor under UIParent (or Minimap, the quest log)
local top, depth = f, 0
while top and depth < 20 do
local p = top.GetParent and top:GetParent()
local pn = p and p.GetName and p:GetName()
if not p or (pn and TOP[pn]) then break end
top, depth = p, depth + 1
end
if top then K.Register(top) end
end
return ok
end
local driver = CreateFrame("Frame", "pfQuest_xpGuideThemeDriver")
driver.quick, driver.slow = 0, 0
driver:SetScript("OnUpdate", function()
this.quick = this.quick + arg1
this.slow = this.slow + arg1
if this.quick < 0.1 then return end
this.quick = 0
local full = this.slow >= 1
if full then this.slow = 0 end
if not K.On() then return end
for _, f in ipairs(K.windows) do
local shown = f:IsShown() and true or false
-- a window that just opened at once; every window, open or not, once a second (so one built hidden is ready before it shows)
if (shown and not f.erWasShown) or full then pcall(Walk, f, 0) end
f.erWasShown = shown
end
end)
-- pfUI keeps the minimap square unless its minimap module is off; OctoPad places its button on the square's edge then.
function K.SquareMinimap()
if not K.On() then return false end
return not (pfUI_config and pfUI_config.disabled and pfUI_config.disabled["minimap"] == "1")
end
------------------------------------------------------------------------------------------------------
-- Text: pfQuest's font and size
------------------------------------------------------------------------------------------------------
-- The guide's text uses pfQuest's font (pfUI's when pfUI is there; pfQuest brings its own otherwise) at the size of pfQuest's
-- quest tracker ("Quest Tracker Font Size" in pfQuest's settings), so the guide reads like pfQuest's own lists. The size can be
-- set in Settings instead (Text size, or /xpg font 13); "pfQuest's" goes back to following pfQuest.
ER.fontStrings = setmetatable({}, { __mode = "k" }) -- every font string that follows the size, with its offset from it
function ER.FontFace()
return (pfUI and pfUI.font_default) or STANDARD_TEXT_FONT or "Fonts\\FRIZQT__.TTF"
end
-- pfQuest's size: its quest tracker's, else pfUI's (or pfQuest's stand-in for it), else 12.
function ER.FontSizePfQuest()
local n = pfQuest_config and tonumber(pfQuest_config["trackerfontsize"])
if n and n >= 6 and n <= 40 then return n end
n = pfUI_config and pfUI_config.global and tonumber(pfUI_config.global.font_size)
if n and n >= 6 and n <= 40 then return n end
return 12
end
-- The size in use: the one set in Settings, or pfQuest's.
function ER.FontSize()
local n = ER.db and tonumber(ER.db.fontSize)
if n and n >= 6 and n <= 40 then return n end
return ER.FontSizePfQuest()
end
-- Puts a font string on the guide's font, at the size in use plus delta (the heading a size up, small print a size or two down).
function ER.ApplyFont(fs, delta, flags)
if not fs or not fs.SetFont then return end
fs.erDelta, fs.erFlags = delta or 0, flags
ER.fontStrings[fs] = true
local size = ER.FontSize() + (delta or 0)
if size < 8 then size = 8 end
pcall(fs.SetFont, fs, ER.FontFace(), size, flags or "")
fs.erFont = true -- the theme leaves it alone
end
-- Sets the size (a number, or nil for pfQuest's), puts every font string on it and lays the windows out again.
function ER.SetFontSize(n)
if not ER.db then return end
ER.db.fontSize = n and tonumber(n) or nil
for fs in pairs(ER.fontStrings) do ER.ApplyFont(fs, fs.erDelta, fs.erFlags) end
if ER.FontsChanged then ER.FontsChanged() end
end
-- The words for the size: "pfQuest's (12)" or "14".
function ER.FontSizeLabel()
if ER.db and tonumber(ER.db.fontSize) then return tostring(ER.FontSize()) end
return "pfQuest's (" .. ER.FontSizePfQuest() .. ")"
end
-- One size smaller (d = -1) or bigger (d = 1), from the size in use, 8 to 24: the Settings arrows.
ER.FONT_MIN, ER.FONT_MAX = 8, 24
function ER.NudgeFontSize(d)
local n = ER.FontSize() + (d or 0)
if n < ER.FONT_MIN then n = ER.FONT_MIN end
if n > ER.FONT_MAX then n = ER.FONT_MAX end
ER.SetFontSize(n)
end
-- /xpg theme and the settings tick: pfUI's look on or off. Windows are built once, so the change shows after a /reload.
function ER.ToggleTheme()
if not ER.db then return end
ER.db.pfuiThemeOff = not ER.db.pfuiThemeOff
local msg
if not K.Available() then
msg = "pfUI is not loaded, so pfQuest xpGuide keeps its own look."
elseif ER.db.pfuiThemeOff then
msg = "pfQuest xpGuide's own look. Type |cffffd100/reload|r to see it."
else
msg = "pfUI's look. Type |cffffd100/reload|r to see it."
end
if ER.Print then ER.Print(msg) end
end
ER.Loaded("Theme.lua")