Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01XfR1apt9f3R7SxBKB2FF2D
898 lines
39 KiB
Lua
898 lines
39 KiB
Lua
-- pfQuest xpGuide: the settings window. Every option and every window of the addon in one place, so nothing needs a
|
|
-- slash command: six pages (Guides, Configuration, Auto mode, Helpers, Usage, Features) picked with the page buttons along the top (or
|
|
-- the sidebar with pfUI's look), each with its ticks and buttons. Guides is where a guide is picked: the groups on the left,
|
|
-- the guides of the group on the right. Usage and Features are text (Help.lua has the words), scrolled with the mouse wheel. The gear on the guide (step box or quest list) opens it, so does right-clicking the minimap button, or /xpg settings.
|
|
|
|
local ER = pfQuest_xpGuide
|
|
local GOLD, GREY, WHITE, END = ER.GOLD, ER.GREY, ER.WHITE, ER.END
|
|
|
|
local W = 640
|
|
local LEFT = 22 -- the left edge of a page's words
|
|
local COL_W = math.floor((W - 44) / 2) -- one of the two columns of ticks
|
|
local TOP_Y = -84 -- where a page starts, under the title, the line about the guide and the page buttons
|
|
local S = { checks = {}, buttons = {}, tabs = {}, pages = {}, helpViews = {} }
|
|
-- With pfUI the window is laid out the way OctoPad's settings are: the pages picked from a sidebar on the left, the title in the
|
|
-- top left corner, each page under a small accent header (Theme.lua). S.side is the sidebar's width, S.top where a page starts.
|
|
local SIDE_W = 132
|
|
S.side, S.top = 0, TOP_Y
|
|
local function Themed() return ER.Skin and ER.Skin.On() end
|
|
|
|
local function Db() return ER.db or {} end
|
|
|
|
local function Running() return ER.Steps and ER.Steps.Running() end
|
|
|
|
local function Hide() if S.frame then S.frame:Hide() end end
|
|
|
|
-- A tick: label, is it on now, turn it on or off, and a short tooltip (tip). wide: the tick has a whole row; part: one of Auto mode's own
|
|
-- ticks (greyed while Auto mode is off). The toggles that already have their own function use it, so the chat line and the windows follow
|
|
-- as with the slash command. A button: label, what the tooltip says, what it does. note: a grey line under the ticks.
|
|
local PAGES = {
|
|
{ title = "Guides", head = "Pick a guide. Every guide for your faction, by level: the one that suits you now is gold.",
|
|
guides = true, checks = {}, buttons = {} },
|
|
{ title = "Configuration", head = "Your guide, how hard it is and how it looks.",
|
|
checks = {
|
|
{ "Lock the guide window",
|
|
function() return Db().guideLocked end,
|
|
function(on)
|
|
Db().guideLocked = on and true or nil
|
|
if ER.GuideFooterChanged then ER.GuideFooterChanged() end
|
|
end,
|
|
tip = "Keep the guide window where it is: no moving or resizing by mistake." },
|
|
{ "Go on to the next guide",
|
|
function() return not Db().autoNextOff end,
|
|
function(on) if ER.db then ER.db.autoNextOff = not on end end,
|
|
tip = "When a guide ends, the next one starts by itself." },
|
|
{ "Ask every 3 levels how it goes",
|
|
function() return not Db().checkinOff end,
|
|
function(on) if ER.db then ER.db.checkinOff = not on end end,
|
|
tip = "Every 3 levels: Too easy, About right or Too hard?" },
|
|
{ "Leave out money steps",
|
|
function() return ER.HasMoney and ER.HasMoney() end,
|
|
function(on) if ER.SetHasMoney then ER.SetHasMoney(on) end end,
|
|
tip = "For when you have money on another character." },
|
|
},
|
|
-- the text size, set with two arrows and the size between them, as when splitting a stack in your bags
|
|
stepper = { "Text size", "The size of the guide's text. Left is smaller, right is bigger.",
|
|
"Follows pfQuest's quest tracker size until you change it. Click the number to follow pfQuest again." },
|
|
buttons = {
|
|
{ "Change difficulty", "Casual, Medium or Hard.", function()
|
|
Hide()
|
|
if ER.ShowWizardMood then ER.ShowWizardMood() end
|
|
end },
|
|
{ "Start guide again", "Back to step 1 of this guide.", function()
|
|
local info = Running() and ER.Steps.Info()
|
|
if info then ER.Steps.Load(ER.Steps.Key(info), true) end
|
|
Hide()
|
|
end },
|
|
{ "Stop the guide", "Close the guide. The Guides page starts one again.", function()
|
|
if Running() then
|
|
ER.Steps.Stop()
|
|
ER.Print("guide stopped.")
|
|
end
|
|
Hide()
|
|
end },
|
|
{ "Find my place", "Puts the guide back where your quest log says you are.", function()
|
|
if ER.FindMyPlace then ER.FindMyPlace() end
|
|
Hide()
|
|
end },
|
|
},
|
|
},
|
|
{ title = "Character", head = "The experience rate of your server and your professions. The Fast guides use them to choose the steps.",
|
|
checks = (function()
|
|
local list = {
|
|
{ "1x experience",
|
|
function() return ER.XPRate and ER.XPRate() == 1 end,
|
|
function() if ER.SetXPRate then ER.SetXPRate(1) end end,
|
|
section = "Experience rate",
|
|
tip = "Normal rates. The Fast guides keep their extra quests." },
|
|
{ "2x experience",
|
|
function() return ER.XPRate and ER.XPRate() == 2 end,
|
|
function() if ER.SetXPRate then ER.SetXPRate(2) end end,
|
|
tip = "Double experience. The Fast guides leave out the quests that a 1x server needs for the same levels." },
|
|
}
|
|
local function Prof(name, first, section, tip)
|
|
table.insert(list, {
|
|
name,
|
|
function() return ER.HasProf and ER.HasProf(name) end,
|
|
function(on) if ER.SetProf then ER.SetProf(name, on) end end,
|
|
section = first and section or nil,
|
|
prof = name,
|
|
tip = tip,
|
|
})
|
|
end
|
|
local PRIMARY = { "Mining", "Herbalism", "Skinning", "Alchemy", "Blacksmithing", "Engineering", "Enchanting",
|
|
"Leatherworking", "Tailoring" }
|
|
local SECONDARY = { "First Aid", "Cooking", "Fishing", "Survival" }
|
|
for i, n in ipairs(PRIMARY) do
|
|
Prof(n, i == 1, "Primary professions", "Tick the ones you have or mean to learn (the game's skill list ticks the ones you have). The guide adds where to train, what to gather on the way and when to go back.")
|
|
end
|
|
for i, n in ipairs(SECONDARY) do
|
|
Prof(n, i == 1, "Secondary professions", "Steps for " .. n .. " while you pass its trainers. First Aid and Cooking are on until you untick them.")
|
|
end
|
|
return list
|
|
end)(),
|
|
note = "Professions you already have are ticked from your skill list and stay ticked.",
|
|
buttons = {} },
|
|
{ title = "Auto mode", head = "pfQuest xpGuide does the clicking at NPCs. Hold Shift when you talk to one to do it yourself.",
|
|
checks = {
|
|
{ "Auto mode",
|
|
function() return not Db().autoOff end,
|
|
function(on) if ER.db then ER.db.autoOff = not on end end,
|
|
tip = "Turns all of the ticks below on or off at once. Hold Shift when you talk to an NPC to do it yourself.", wide = true },
|
|
{ "Take and hand in quests", section = "Quest givers",
|
|
function() return not Db().autoquestOff end,
|
|
function(on) if ER.db then ER.db.autoquestOff = not on end end,
|
|
tip = "Takes your route's quests and hands in finished ones. Rewards: you pick; if none fit you, it takes the one that sells for the most.", part = true },
|
|
{ "Pick quests in NPC menus",
|
|
function() return not Db().automenuOff end,
|
|
function(on) if ER.db then ER.db.automenuOff = not on end end,
|
|
tip = "When an NPC has several quests, picks the right one.", part = true },
|
|
{ "Take the flight on fly steps", section = "Travel",
|
|
function() return not Db().autoflightOff end,
|
|
function(on) if ER.db then ER.db.autoflightOff = not on end end,
|
|
tip = "Opens the flight map and flies to the step's town.", part = true },
|
|
{ "Set my hearthstone at the inn",
|
|
function() return not Db().autoinnOff end,
|
|
function(on) if ER.db then ER.db.autoinnOff = not on end end,
|
|
tip = "On a set-hearthstone step, at that inn only.", part = true },
|
|
{ "Sell grey items and repair", section = "Vendors",
|
|
function() return not Db().autosellOff end,
|
|
function(on) if ER.db then ER.db.autosellOff = not on end end,
|
|
tip = "At any vendor. Never white or quest items.", part = true },
|
|
{ "Use your hearthstone button", section = "Always (with Auto mode off too)",
|
|
function() return not Db().hearthBtnOff end,
|
|
function(on)
|
|
if ER.db then ER.db.hearthBtnOff = not on end
|
|
if ER.StepsChanged then ER.StepsChanged() end
|
|
end,
|
|
tip = "A button on hearth steps. It never hearths by itself." },
|
|
},
|
|
buttons = {},
|
|
},
|
|
{ title = "Helpers", head = "Extra help on screen: the arrow, markers, tips and tooltips.",
|
|
checks = {
|
|
{ "Show the arrow", section = "Arrow",
|
|
function() return not Db().arrowOff end,
|
|
function(on) if (not Db().arrowOff) ~= on and ER.ToggleArrow then ER.ToggleArrow() end end,
|
|
tip = "The arrow that points the way. The arrow icon under the guide window does the same." },
|
|
{ "Use pfQuest's arrow",
|
|
function() return not Db().pfArrowOff end,
|
|
function(on) if (not Db().pfArrowOff) ~= on and ER.TogglePfArrow then ER.TogglePfArrow() end end,
|
|
tip = "With pfQuest, its arrow points the way and ours stays hidden: one arrow, not two. With pfQuest SmartArrow installed it is routed: zone exits, flight paths, boats, roads, around obstacles." },
|
|
{ "Quest markers on nameplates", section = "Enemies and NPCs",
|
|
function() return not Db().skullsOff end,
|
|
function(on) if (not Db().skullsOff) ~= on and ER.ToggleSkulls then ER.ToggleSkulls() end end,
|
|
tip = "Left of the level on nameplates: a skull on mobs to kill, a sack on mobs that drop what you need, ! on who gives the step's quest, ? on who takes it back. A chain quest's shape sits behind. V shows enemy nameplates, Shift-V friendly ones." },
|
|
{ "Easy / Hard on enemy tooltips",
|
|
function() return not Db().rateOff end,
|
|
function(on) if ER.db then ER.db.rateOff = not on end end,
|
|
tip = "Enemy tooltips say Easy, Medium or Hard." },
|
|
{ "Show the tips box", section = "Tips and warnings",
|
|
function() return not Db().tipsOff end,
|
|
function(on) if (not Db().tipsOff) ~= on and ER.ToggleTips then ER.ToggleTips() end end,
|
|
tip = "The \"pfQuest xpGuide says\" box under the guide: questions (money, moving on) and tips." },
|
|
{ "Show warnings",
|
|
function() return not Db().warnOff end,
|
|
function(on)
|
|
if ER.db then ER.db.warnOff = not on end
|
|
if ER.StepsChanged then ER.StepsChanged() end
|
|
end,
|
|
tip = "Dangerous mobs, caves and mines." },
|
|
{ "Show grind spots",
|
|
function() return not Db().grindOff end,
|
|
function(on) if ER.db then ER.db.grindOff = not on end end,
|
|
tip = "Safe mobs to kill when there are no good quests." },
|
|
{ "Popup on a chain's first quest",
|
|
function() return Db().chainPopup end,
|
|
function(on) if ER.db then ER.db.chainPopup = on end end,
|
|
tip = "Says how long the chain is and what comes next." },
|
|
{ "Use pfUI's look", section = "Look and other",
|
|
function() return not Db().pfuiThemeOff end,
|
|
function(on) if (not Db().pfuiThemeOff) ~= on and ER.ToggleTheme then ER.ToggleTheme() end end,
|
|
tip = "With pfUI, pfQuest xpGuide's windows take pfUI's colours, font and borders. Takes effect after /reload." },
|
|
{ "Minimap button",
|
|
function() return not Db().minimapHidden end,
|
|
function(on)
|
|
if ER.db then ER.db.minimapHidden = not on end
|
|
if ER.UpdateMinimapButton then ER.UpdateMinimapButton() end
|
|
end,
|
|
tip = "The pfQuest xpGuide button on the minimap." },
|
|
{ "Tell my party when I hand in",
|
|
function() return Db().partyAnnounce end,
|
|
function(on) if ER.db then ER.db.partyAnnounce = on end end,
|
|
tip = "One line in party chat." },
|
|
},
|
|
buttons = {},
|
|
},
|
|
{ title = "Usage", head = "How to use pfQuest xpGuide, and what it works with.", help = "usage", checks = {}, buttons = {} },
|
|
{ title = "Features", head = "What pfQuest xpGuide does, and what changed in each version.", help = "features", checks = {}, buttons = {} },
|
|
}
|
|
|
|
-- The row along the bottom, under every page.
|
|
local BOTTOM = {
|
|
{ "Close", "Close the settings.", function() Hide() end },
|
|
}
|
|
|
|
-- Every tick of every page in one list, in the order they are made; each one knows its page.
|
|
local CHECKS = {}
|
|
for p, page in ipairs(PAGES) do
|
|
for _, c in ipairs(page.checks) do
|
|
c.page = p
|
|
table.insert(CHECKS, c)
|
|
end
|
|
end
|
|
|
|
-- What the window holds, for the tests: each page's title, its ticks (labels), how many are Auto mode's part ticks, its buttons (labels);
|
|
-- the bottom row; the page open now.
|
|
function ER.SettingsInfo()
|
|
local out = { pages = {}, bottom = {}, page = S.page }
|
|
for _, page in ipairs(PAGES) do
|
|
local parts, labels, buttons, sections = 0, {}, {}, {}
|
|
for _, c in ipairs(page.checks) do
|
|
if c.part then parts = parts + 1 end
|
|
if c.section then table.insert(sections, c.section) end
|
|
table.insert(labels, c[1])
|
|
end
|
|
for _, b in ipairs(page.buttons) do table.insert(buttons, b[1]) end
|
|
table.insert(out.pages, { title = page.title, head = page.head, checks = labels, parts = parts, buttons = buttons, sections = sections, help = page.help })
|
|
end
|
|
for _, b in ipairs(BOTTOM) do table.insert(out.bottom, b[1]) end
|
|
return out
|
|
end
|
|
|
|
-- A window taller than the screen is made smaller to fit: 1 when it fits (or the screen height is not known), else the share that fits
|
|
-- with 20 units to spare.
|
|
function ER.SettingsScale(height, screen)
|
|
if type(height) == "number" and height > 0 and type(screen) == "number" and screen >= 300 and height > screen - 20 then
|
|
return (screen - 20) / height
|
|
end
|
|
return 1
|
|
end
|
|
|
|
local function Refresh()
|
|
local off = Db().autoOff
|
|
for i, c in ipairs(S.checks) do
|
|
c:SetChecked(CHECKS[i][2]() and 1 or nil)
|
|
-- Auto mode's own ticks are greyed and cannot be clicked while Auto mode is off (they keep their setting for when
|
|
-- it is back on).
|
|
if CHECKS[i].part then
|
|
c:SetAlpha(off and 0.45 or 1)
|
|
if off then c:Disable() else c:Enable() end
|
|
end
|
|
end
|
|
local info = Running() and ER.Steps.Info()
|
|
local mode = ER.MODES and ER.Mode and ER.MODES[ER.Mode()]
|
|
S.sub:SetText(GREY .. "Difficulty: " .. END .. WHITE .. (mode and mode.label or "?") .. END .. GREY .. " Guide: " .. END ..
|
|
WHITE .. (info and (info.title or info.name) or "none") .. END ..
|
|
((info and info.fast and ER.XPRate) and (GREY .. ", " .. ER.XPRate() .. "x exp" .. END) or ""))
|
|
-- the professions show your skill in them
|
|
for i, c in ipairs(S.checks) do
|
|
local d = CHECKS[i]
|
|
if d.prof then
|
|
local label = getglobal("pfQuest_xpGuideSettingsCheck" .. i .. "Text")
|
|
if label and ER.ProfDetail then
|
|
label:SetText(d.prof .. " " .. (ER.KnowsProf(d.prof) and WHITE or GREY) .. ER.ProfDetail(d.prof) .. END)
|
|
end
|
|
end
|
|
end
|
|
if S.FillStepper then S.FillStepper() end
|
|
if S.FillGuides then S.FillGuides() end
|
|
if S.FillHelp then S.FillHelp() end
|
|
end
|
|
|
|
-- A page by its number or its name ("Guides", "settings", ...); nil when there is none.
|
|
local function PageIndex(n)
|
|
if type(n) == "string" then
|
|
local want = string.lower(n)
|
|
for i, page in ipairs(PAGES) do if string.lower(page.title) == want then return i end end
|
|
n = tonumber(n)
|
|
end
|
|
n = tonumber(n)
|
|
if n and PAGES[n] then return n end
|
|
return nil
|
|
end
|
|
|
|
-- Shows a page (its number or name) and keeps it as the page to open next time.
|
|
local function ShowPage(n)
|
|
n = PageIndex(n) or 1
|
|
S.page = n
|
|
if ER.db then ER.db.settingsPage = n end
|
|
for i, page in ipairs(S.pages) do
|
|
if i == n then page:Show() else page:Hide() end
|
|
local tab = S.tabs[i]
|
|
if tab then
|
|
if i == n then tab:LockHighlight() else tab:UnlockHighlight() end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function Tooltip(owner, title, text)
|
|
GameTooltip:SetOwner(owner, "ANCHOR_RIGHT")
|
|
GameTooltip:SetText(title)
|
|
if text then GameTooltip:AddLine(text, 1, 1, 1, 1) end
|
|
GameTooltip:Show()
|
|
end
|
|
|
|
local function Button(name, parent, def, width)
|
|
local b = CreateFrame("Button", name, parent, "UIPanelButtonTemplate")
|
|
b:SetWidth(width)
|
|
b:SetHeight(22)
|
|
b:SetText(def.label and def.label() or def[1])
|
|
b.def = def
|
|
b:RegisterForClicks("LeftButtonUp", "RightButtonUp")
|
|
b:SetScript("OnClick", function()
|
|
this.def[3](arg1 == "RightButton")
|
|
if this.def.label then this:SetText(this.def.label()) end
|
|
end)
|
|
b:SetScript("OnEnter", function() Tooltip(this, this.def[1], this.def[2]) end)
|
|
b:SetScript("OnLeave", function() GameTooltip:Hide() end)
|
|
return b
|
|
end
|
|
|
|
------------------------------------------------------------------------------------------------------
|
|
-- The Guides page: the groups on the left, the group's guides on the right (scrolls with the mouse wheel or its arrows)
|
|
------------------------------------------------------------------------------------------------------
|
|
|
|
local GREEN = ER.GREEN
|
|
local ROWS, ROW_H = 14, 16
|
|
local GROUP_W = 176
|
|
|
|
local function Row(name, parent, w)
|
|
local r = CreateFrame("Button", name, parent)
|
|
r:SetWidth(w)
|
|
r:SetHeight(ROW_H)
|
|
local glow = r:CreateTexture(nil, "HIGHLIGHT")
|
|
glow:SetTexture("Interface\\QuestFrame\\UI-QuestTitleHighlight")
|
|
glow:SetBlendMode("ADD")
|
|
glow:SetAllPoints(r)
|
|
r.pick = r:CreateTexture(nil, "BACKGROUND")
|
|
r.pick:SetTexture(1, 1, 1, 0.08)
|
|
r.pick:SetAllPoints(r)
|
|
r.pick:Hide()
|
|
r.text = r:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall")
|
|
r.text:SetPoint("LEFT", r, "LEFT", 4, 0)
|
|
r.text:SetWidth(w - 8)
|
|
r.text:SetHeight(14)
|
|
r.text:SetJustifyH("LEFT")
|
|
return r
|
|
end
|
|
|
|
-- Which group to show: the one picked, else the one holding the guide that runs now, else the one that suits you best.
|
|
local function OpenGroup(groups)
|
|
if S.group then
|
|
for _, grp in ipairs(groups) do if grp.name == S.group then return grp end end
|
|
end
|
|
local running, best = ER.Steps.Info(), ER.Steps.Suggest()[1]
|
|
for _, want in ipairs({ running, best }) do
|
|
for _, grp in ipairs(groups) do
|
|
for _, g in ipairs(grp.guides) do if g == want then return grp end end
|
|
end
|
|
end
|
|
return groups[1]
|
|
end
|
|
|
|
local function FillGuides()
|
|
if not S.groupRows then return end
|
|
local groups = ER.Steps.Groups()
|
|
local best = ER.Steps.Suggest()[1]
|
|
local running = ER.Steps.Info()
|
|
local grp = OpenGroup(groups)
|
|
for i, r in ipairs(S.groupRows) do
|
|
local g = groups[i]
|
|
if g then
|
|
local has = false
|
|
for _, x in ipairs(g.guides) do if x == best then has = true end end
|
|
local now = running and running.group == g.name
|
|
r.text:SetText((has and GOLD or WHITE) .. ER.GroupLabel(g.name) .. END .. (now and (GREEN .. " (now)" .. END) or "") ..
|
|
GREY .. " >" .. END)
|
|
r.grp = g
|
|
if g == grp then r.pick:Show() else r.pick:Hide() end
|
|
r:Show()
|
|
else
|
|
r.grp = nil
|
|
r:Hide()
|
|
end
|
|
end
|
|
local list = grp and grp.guides or {}
|
|
local total = table.getn(list)
|
|
local most = math.max(0, total - ROWS)
|
|
S.offset = math.max(0, math.min(S.offset or 0, most))
|
|
for i, r in ipairs(S.guideRows) do
|
|
local g = list[i + S.offset]
|
|
if g then
|
|
local text = g.title or g.name
|
|
if running == g then
|
|
text = GREEN .. text .. " (now)" .. END
|
|
elseif g == best then
|
|
text = GOLD .. text .. END .. GREY .. " (best)" .. END
|
|
else
|
|
text = WHITE .. text .. END
|
|
end
|
|
r.text:SetText(text)
|
|
r.guide = g
|
|
r:Show()
|
|
else
|
|
r.guide = nil
|
|
r:Hide()
|
|
end
|
|
end
|
|
S.listTitle:SetText(grp and (GOLD .. ER.GroupLabel(grp.name) .. END .. GREY .. " " .. total .. (total == 1 and " guide" or " guides") .. END) or "")
|
|
if S.offset > 0 then S.up:Enable() else S.up:Disable() end
|
|
if S.offset < most then S.down:Enable() else S.down:Disable() end
|
|
if most > 0 then S.up:Show() S.down:Show() else S.up:Hide() S.down:Hide() end
|
|
-- the running casual-route zone's place on the route, under its group's guides
|
|
local where = grp and running and running.group == grp.name and ER.RouteLine and ER.RouteLine()
|
|
if where then S.routeLine:SetText(GREY .. where .. END) S.routeLine:Show() else S.routeLine:Hide() end
|
|
end
|
|
S.FillGuides = FillGuides
|
|
|
|
local function Scroll(by)
|
|
S.offset = (S.offset or 0) + by
|
|
FillGuides()
|
|
end
|
|
|
|
function S.BuildGuides(page, y)
|
|
local inner = W - 2 * LEFT
|
|
local listX = LEFT + GROUP_W + 10
|
|
local listW = inner - GROUP_W - 10 - 22
|
|
local groupsHead = page:CreateFontString(nil, "ARTWORK", "GameFontNormalSmall")
|
|
groupsHead:SetPoint("TOPLEFT", page, "TOPLEFT", LEFT + 4, y)
|
|
groupsHead:SetText(GREY .. "Group" .. END)
|
|
S.listTitle = page:CreateFontString(nil, "ARTWORK", "GameFontNormalSmall")
|
|
S.listTitle:SetPoint("TOPLEFT", page, "TOPLEFT", listX + 4, y)
|
|
S.listTitle:SetJustifyH("LEFT")
|
|
y = y - 16
|
|
-- a faint field behind each list
|
|
for _, box in ipairs({ { LEFT, GROUP_W }, { listX, listW + 22 } }) do
|
|
local t = page:CreateTexture(nil, "BACKGROUND")
|
|
t:SetTexture(0, 0, 0, 0.25)
|
|
t:SetPoint("TOPLEFT", page, "TOPLEFT", box[1], y + 2)
|
|
t:SetWidth(box[2])
|
|
t:SetHeight(ROWS * ROW_H + 4)
|
|
end
|
|
S.groupRows, S.guideRows = {}, {}
|
|
for i = 1, ROWS do
|
|
local r = Row("pfQuest_xpGuideGuideMenuGroup" .. i, page, GROUP_W)
|
|
r:SetPoint("TOPLEFT", page, "TOPLEFT", LEFT, y - (i - 1) * ROW_H)
|
|
r:SetScript("OnClick", function()
|
|
if not this.grp then return end
|
|
S.group, S.offset = this.grp.name, 0
|
|
FillGuides()
|
|
end)
|
|
r:SetScript("OnEnter", function()
|
|
if not this.grp then return end
|
|
Tooltip(this, ER.GroupLabel(this.grp.name), "Click to see its guides.")
|
|
end)
|
|
r:SetScript("OnLeave", function() GameTooltip:Hide() end)
|
|
r:Hide()
|
|
S.groupRows[i] = r
|
|
end
|
|
local list = CreateFrame("Frame", "pfQuest_xpGuideGuideMenuPanel", page)
|
|
list:SetPoint("TOPLEFT", page, "TOPLEFT", listX, y)
|
|
list:SetWidth(listW)
|
|
list:SetHeight(ROWS * ROW_H)
|
|
list:EnableMouseWheel(true)
|
|
list:SetScript("OnMouseWheel", function() Scroll(arg1 > 0 and -3 or 3) end)
|
|
for i = 1, ROWS do
|
|
local r = Row("pfQuest_xpGuideGuideMenuGuide" .. i, list, listW)
|
|
r:SetPoint("TOPLEFT", list, "TOPLEFT", 0, -(i - 1) * ROW_H)
|
|
r:EnableMouseWheel(true)
|
|
r:SetScript("OnMouseWheel", function() Scroll(arg1 > 0 and -3 or 3) end)
|
|
r:SetScript("OnClick", function()
|
|
local g = this.guide
|
|
if not g then return end
|
|
Hide()
|
|
if ER.ChooseGuide then ER.ChooseGuide(g) else ER.StartGuide(ER.Steps.Key(g), nil, nil, true) end
|
|
end)
|
|
r:SetScript("OnEnter", function()
|
|
local g = this.guide
|
|
if not g then return end
|
|
local body = "Levels " .. g.lo .. " to " .. g.hi .. "."
|
|
if g.about and g.about ~= "" then body = body .. "\n" .. g.about end
|
|
GameTooltip:SetOwner(this, "ANCHOR_RIGHT")
|
|
GameTooltip:SetText(g.title or g.name)
|
|
GameTooltip:AddLine(body, 1, 1, 1, 1)
|
|
GameTooltip:AddLine("Click to follow this guide.", 0.6, 0.6, 0.6, 1)
|
|
GameTooltip:Show()
|
|
end)
|
|
r:SetScript("OnLeave", function() GameTooltip:Hide() end)
|
|
r:Hide()
|
|
S.guideRows[i] = r
|
|
end
|
|
local function Arrow(name, dir, point, dy)
|
|
local b = CreateFrame("Button", name, page)
|
|
b:SetWidth(18)
|
|
b:SetHeight(18)
|
|
local which = dir < 0 and "Up" or "Down"
|
|
b:SetNormalTexture("Interface\\Buttons\\UI-ScrollBar-Scroll" .. which .. "Button-Up")
|
|
b:SetPushedTexture("Interface\\Buttons\\UI-ScrollBar-Scroll" .. which .. "Button-Down")
|
|
b:SetDisabledTexture("Interface\\Buttons\\UI-ScrollBar-Scroll" .. which .. "Button-Disabled")
|
|
b:SetHighlightTexture("Interface\\Buttons\\UI-ScrollBar-Scroll" .. which .. "Button-Highlight", "ADD")
|
|
b:SetPoint(point, list, point == "TOPLEFT" and "TOPRIGHT" or "BOTTOMRIGHT", 2, dy)
|
|
b.dir = dir
|
|
b:SetScript("OnClick", function() Scroll(this.dir * (ROWS - 1)) end)
|
|
return b
|
|
end
|
|
S.up = Arrow("pfQuest_xpGuideGuideMenuUp", -1, "TOPLEFT", 0)
|
|
S.down = Arrow("pfQuest_xpGuideGuideMenuDown", 1, "BOTTOMLEFT", 0)
|
|
y = y - ROWS * ROW_H - 6
|
|
S.routeLine = page:CreateFontString("pfQuest_xpGuideGuideMenuLine", "ARTWORK", "GameFontHighlightSmall")
|
|
S.routeLine:SetPoint("TOPLEFT", page, "TOPLEFT", listX + 4, y)
|
|
S.routeLine:SetWidth(listW)
|
|
S.routeLine:SetHeight(14)
|
|
S.routeLine:SetJustifyH("LEFT")
|
|
S.routeLine:Hide()
|
|
y = y - 16
|
|
return y
|
|
end
|
|
|
|
------------------------------------------------------------------------------------------------------
|
|
-- The Usage and Features pages: the words of Help.lua in a box that scrolls with the mouse wheel or its arrows
|
|
------------------------------------------------------------------------------------------------------
|
|
|
|
local WHEEL = 36
|
|
local function HelpScroll(view, delta)
|
|
local at = view:GetVerticalScroll() or 0
|
|
local to = math.max(0, math.min(view.range or 0, at + delta))
|
|
view:SetVerticalScroll(to)
|
|
view.at = to
|
|
if view.up then
|
|
if to <= 0 then view.up:Disable() else view.up:Enable() end
|
|
if to >= (view.range or 0) then view.down:Disable() else view.down:Enable() end
|
|
end
|
|
end
|
|
|
|
function S.BuildHelp(page, y, key)
|
|
local w = W - 2 * LEFT - 24
|
|
local view = CreateFrame("ScrollFrame", "pfQuest_xpGuideHelpView" .. key, page)
|
|
view:SetPoint("TOPLEFT", page, "TOPLEFT", LEFT, y)
|
|
view:SetWidth(w)
|
|
view:SetHeight(200)
|
|
local child = CreateFrame("Frame", "pfQuest_xpGuideHelpText" .. key, view)
|
|
child:SetWidth(w)
|
|
child:SetHeight(10)
|
|
view:SetScrollChild(child)
|
|
local text = child:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall")
|
|
text:SetPoint("TOPLEFT", child, "TOPLEFT", 0, 0)
|
|
text:SetJustifyH("LEFT")
|
|
text:SetJustifyV("TOP")
|
|
if ER.ApplyFont then ER.ApplyFont(text, 0) end
|
|
view.key, view.text, view.child, view.w, view.top = key, text, child, w, -y
|
|
view:EnableMouseWheel(true)
|
|
view:SetScript("OnMouseWheel", function() HelpScroll(this, -(arg1 or 0) * WHEEL) end)
|
|
local function Arrow(name, dir)
|
|
local b = CreateFrame("Button", name, page)
|
|
b:SetWidth(18)
|
|
b:SetHeight(18)
|
|
local which = dir < 0 and "Up" or "Down"
|
|
b:SetNormalTexture("Interface\\Buttons\\UI-ScrollBar-Scroll" .. which .. "Button-Up")
|
|
b:SetPushedTexture("Interface\\Buttons\\UI-ScrollBar-Scroll" .. which .. "Button-Down")
|
|
b:SetDisabledTexture("Interface\\Buttons\\UI-ScrollBar-Scroll" .. which .. "Button-Disabled")
|
|
b:SetHighlightTexture("Interface\\Buttons\\UI-ScrollBar-Scroll" .. which .. "Button-Highlight", "ADD")
|
|
b:SetPoint(dir < 0 and "TOPLEFT" or "BOTTOMLEFT", view, dir < 0 and "TOPRIGHT" or "BOTTOMRIGHT", 4, 0)
|
|
b.dir = dir
|
|
b:SetScript("OnClick", function() HelpScroll(view, this.dir * view:GetHeight() * 0.8) end)
|
|
return b
|
|
end
|
|
view.up, view.down = Arrow("pfQuest_xpGuideHelpUp" .. key, -1), Arrow("pfQuest_xpGuideHelpDown" .. key, 1)
|
|
table.insert(S.helpViews, view)
|
|
return y
|
|
end
|
|
|
|
-- The words, fitted to the box; how far they can scroll follows from how tall they are.
|
|
function S.FillHelp()
|
|
for _, view in ipairs(S.helpViews) do
|
|
local words = ER.HelpText and ER.HelpText(view.key) or ""
|
|
local h = ER.FitHeight(view.text, words, view.w, 100)
|
|
view.child:SetHeight(h)
|
|
view.range = math.max(0, h - view:GetHeight())
|
|
HelpScroll(view, 0)
|
|
end
|
|
end
|
|
|
|
-- Builds one page's ticks, note and buttons in its own frame and returns how tall it is. Ticks sit in two columns; a wide tick has a whole
|
|
-- row. The first of a pair waits (pendingH) for the second, so the pair is as tall as the taller of the two labels.
|
|
local function BuildPage(p, def, nc, nb)
|
|
local page = CreateFrame("Frame", "pfQuest_xpGuideSettingsPage" .. p, S.frame)
|
|
page:SetPoint("TOPLEFT", S.frame, "TOPLEFT", S.side, S.top)
|
|
page:SetWidth(W)
|
|
S.pages[p] = page
|
|
|
|
local y = 0
|
|
local head = page:CreateFontString(nil, "ARTWORK", "GameFontNormal")
|
|
head:SetPoint("TOPLEFT", page, "TOPLEFT", LEFT, y)
|
|
head:SetJustifyH("LEFT")
|
|
local rule = page:CreateTexture(nil, "ARTWORK")
|
|
rule:SetHeight(1)
|
|
rule:SetWidth(W - 2 * LEFT)
|
|
if Themed() then
|
|
-- OctoPad's header: the page's name in small accent capitals with a thin accent line, its sentence in grey under it.
|
|
head:SetText(def.title)
|
|
ER.Skin.Header(head, rule)
|
|
rule:SetPoint("TOPLEFT", page, "TOPLEFT", LEFT, y - 13)
|
|
local sentence = page:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall")
|
|
sentence:SetPoint("TOPLEFT", page, "TOPLEFT", LEFT, y - 20)
|
|
sentence:SetJustifyH("LEFT")
|
|
y = y - 20 - ER.FitHeight(sentence, GREY .. def.head .. END, W - 2 * LEFT, 12) - 4
|
|
else
|
|
y = y - ER.FitHeight(head, def.head, W - 2 * LEFT, 14) - 4
|
|
rule:SetTexture(1, 1, 1, 0.15)
|
|
rule:SetPoint("TOPLEFT", page, "TOPLEFT", LEFT, y)
|
|
end
|
|
y = y - 6
|
|
if def.guides then y = S.BuildGuides(page, y) end
|
|
if def.help then y = S.BuildHelp(page, y, def.help) end
|
|
|
|
local col, pendingH = 0, nil
|
|
for _, c in ipairs(def.checks) do
|
|
nc = nc + 1
|
|
if (c.wide or c.section) and pendingH then
|
|
y = y - pendingH
|
|
pendingH, col = nil, 0
|
|
end
|
|
-- a small heading over a group of ticks
|
|
if c.section then
|
|
y = y - 4
|
|
local sh = page:CreateFontString(nil, "ARTWORK", "GameFontNormalSmall")
|
|
sh:SetPoint("TOPLEFT", page, "TOPLEFT", LEFT + 4, y)
|
|
sh:SetJustifyH("LEFT")
|
|
local accent = Themed() and ER.Skin.ACCENT or GOLD
|
|
sh:SetText(accent .. string.upper(c.section) .. END)
|
|
local line = page:CreateTexture(nil, "ARTWORK")
|
|
line:SetHeight(1)
|
|
line:SetPoint("LEFT", sh, "RIGHT", 6, 0)
|
|
line:SetPoint("RIGHT", page, "LEFT", W - LEFT, 0)
|
|
line:SetTexture(1, 1, 1, 0.08)
|
|
S.sections = S.sections or {}
|
|
table.insert(S.sections, c.section)
|
|
y = y - 15
|
|
end
|
|
local b = CreateFrame("CheckButton", "pfQuest_xpGuideSettingsCheck" .. nc, page, "UICheckButtonTemplate")
|
|
b:SetWidth(24)
|
|
b:SetHeight(24)
|
|
local x, labelW = LEFT, W - 2 * LEFT - 30
|
|
if not c.wide then
|
|
x = LEFT + col * COL_W + (c.part and 10 or 0)
|
|
labelW = COL_W - 34 - (c.part and 10 or 0)
|
|
end
|
|
b:SetPoint("TOPLEFT", page, "TOPLEFT", x, y)
|
|
local rowH = 24
|
|
local label = getglobal("pfQuest_xpGuideSettingsCheck" .. nc .. "Text")
|
|
if label then
|
|
label:ClearAllPoints()
|
|
label:SetPoint("TOPLEFT", b, "TOPRIGHT", 0, -4)
|
|
label:SetJustifyH("LEFT")
|
|
rowH = math.max(24, ER.FitHeight(label, c[1], labelW, 16) + 8)
|
|
end
|
|
b.index, b.page = nc, p
|
|
b:SetScript("OnClick", function()
|
|
local on = this:GetChecked() and true or false
|
|
CHECKS[this.index][3](on)
|
|
Refresh()
|
|
end)
|
|
b:SetScript("OnEnter", function()
|
|
local d = CHECKS[this.index]
|
|
Tooltip(this, d[1], d.tip)
|
|
end)
|
|
b:SetScript("OnLeave", function() GameTooltip:Hide() end)
|
|
S.checks[nc] = b
|
|
if c.wide then
|
|
y = y - rowH
|
|
elseif col == 0 then
|
|
pendingH, col = rowH, 1
|
|
else
|
|
y = y - math.max(pendingH or 24, rowH)
|
|
pendingH, col = nil, 0
|
|
end
|
|
end
|
|
if pendingH then y = y - pendingH end
|
|
|
|
if def.note then
|
|
y = y - 4
|
|
local note = page:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall")
|
|
note:SetPoint("TOPLEFT", page, "TOPLEFT", LEFT + 4, y)
|
|
note:SetJustifyH("LEFT")
|
|
y = y - ER.FitHeight(note, GREY .. def.note .. END, W - 2 * LEFT - 4, 14)
|
|
end
|
|
|
|
|
|
if def.stepper then
|
|
y = y - 6
|
|
local st = def.stepper
|
|
local label = page:CreateFontString(nil, "ARTWORK", "GameFontHighlight")
|
|
label:SetPoint("TOPLEFT", page, "TOPLEFT", LEFT + 6, y - 5)
|
|
label:SetText(st[1])
|
|
local function Arrow(name, dir)
|
|
local b = CreateFrame("Button", name, page)
|
|
b:SetWidth(16)
|
|
b:SetHeight(16)
|
|
local side = (dir < 0) and "Left" or "Right"
|
|
b:SetNormalTexture("Interface\\MoneyFrame\\Arrow-" .. side .. "-Up")
|
|
b:SetPushedTexture("Interface\\MoneyFrame\\Arrow-" .. side .. "-Down")
|
|
b:SetDisabledTexture("Interface\\MoneyFrame\\Arrow-" .. side .. "-Disabled")
|
|
b:SetHighlightTexture("Interface\\Buttons\\UI-Common-MouseHilight", "ADD")
|
|
b.dir = dir
|
|
b:SetScript("OnClick", function()
|
|
if ER.NudgeFontSize then ER.NudgeFontSize(this.dir) end
|
|
if S.FillStepper then S.FillStepper() end
|
|
end)
|
|
b:SetScript("OnEnter", function() Tooltip(this, (this.dir < 0) and "Smaller text" or "Bigger text", st[2]) end)
|
|
b:SetScript("OnLeave", function() GameTooltip:Hide() end)
|
|
return b
|
|
end
|
|
local left = Arrow("pfQuest_xpGuideSettingsSizeLeft", -1)
|
|
left:SetPoint("TOPLEFT", page, "TOPLEFT", LEFT + 150, y - 3)
|
|
-- the size, between the arrows, on a dark field like the bag split's
|
|
local box = CreateFrame("Button", "pfQuest_xpGuideSettingsSizeValue", page)
|
|
box:SetWidth(64)
|
|
box:SetHeight(20)
|
|
box:SetPoint("LEFT", left, "RIGHT", 4, 0)
|
|
local fill = box:CreateTexture(nil, "BACKGROUND")
|
|
fill:SetTexture(0, 0, 0, 0.5)
|
|
fill:SetAllPoints(box)
|
|
box.text = box:CreateFontString(nil, "ARTWORK", "GameFontHighlight")
|
|
box.text:SetPoint("CENTER", box, "CENTER", 0, 0)
|
|
box:SetScript("OnClick", function()
|
|
if ER.SetFontSize then ER.SetFontSize(nil) end
|
|
if S.FillStepper then S.FillStepper() end
|
|
end)
|
|
box:SetScript("OnEnter", function() Tooltip(this, st[1], st[3]) end)
|
|
box:SetScript("OnLeave", function() GameTooltip:Hide() end)
|
|
local right = Arrow("pfQuest_xpGuideSettingsSizeRight", 1)
|
|
right:SetPoint("LEFT", box, "RIGHT", 4, 0)
|
|
S.FillStepper = function()
|
|
local n = ER.FontSize and ER.FontSize() or 12
|
|
local own = ER.db and tonumber(ER.db.fontSize)
|
|
box.text:SetText(WHITE .. n .. END .. (own and "" or (GREY .. " pfQuest" .. END)))
|
|
if n <= (ER.FONT_MIN or 8) then left:Disable() else left:Enable() end
|
|
if n >= (ER.FONT_MAX or 24) then right:Disable() else right:Enable() end
|
|
end
|
|
S.FillStepper()
|
|
y = y - 26
|
|
end
|
|
if table.getn(def.buttons) > 0 then y = y - 8 end
|
|
local bw = math.floor((W - 2 * LEFT - 8) / 2)
|
|
for i, bd in ipairs(def.buttons) do
|
|
nb = nb + 1
|
|
local b = Button("pfQuest_xpGuideSettingsButton" .. nb, page, bd, bw)
|
|
local bc = math.mod(i - 1, 2)
|
|
b:SetPoint("TOPLEFT", page, "TOPLEFT", LEFT + 2 + bc * (bw + 8), y)
|
|
S.buttons[nb] = b
|
|
if bc == 1 then y = y - 26 end
|
|
end
|
|
if math.mod(table.getn(def.buttons), 2) == 1 then y = y - 26 end
|
|
|
|
local height = -y + 6
|
|
page:SetHeight(height)
|
|
return height, nc, nb
|
|
end
|
|
|
|
local function Build()
|
|
local themed = Themed()
|
|
S.side, S.top = themed and SIDE_W or 0, themed and -58 or TOP_Y
|
|
local f = CreateFrame("Frame", "pfQuest_xpGuideSettings", UIParent)
|
|
S.frame = f
|
|
f:SetWidth(W + S.side)
|
|
f:SetFrameStrata("DIALOG")
|
|
f:SetPoint("CENTER", UIParent, "CENTER", 0, 40)
|
|
f:SetClampedToScreen(true)
|
|
f:EnableMouse(true)
|
|
f:SetMovable(true)
|
|
f:RegisterForDrag("LeftButton")
|
|
f:SetScript("OnDragStart", function() this:StartMoving() end)
|
|
f:SetScript("OnDragStop", function() this:StopMovingOrSizing() end)
|
|
f:SetBackdrop({
|
|
bgFile = "Interface\\DialogFrame\\UI-DialogBox-Background",
|
|
edgeFile = "Interface\\DialogFrame\\UI-DialogBox-Border",
|
|
tile = true, tileSize = 32, edgeSize = 32,
|
|
insets = { left = 11, right = 12, top = 12, bottom = 11 },
|
|
})
|
|
if ER.Skin then ER.Skin.Window(f, nil) end
|
|
f:Hide()
|
|
table.insert(UISpecialFrames, "pfQuest_xpGuideSettings")
|
|
|
|
local title = f:CreateFontString(nil, "ARTWORK", "GameFontNormalLarge")
|
|
S.sub = f:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall")
|
|
local close = CreateFrame("Button", "pfQuest_xpGuideSettingsClose", f, "UIPanelCloseButton")
|
|
close:SetPoint("TOPRIGHT", f, "TOPRIGHT", -6, -6)
|
|
local count = table.getn(PAGES)
|
|
if themed then
|
|
-- OctoPad's title: the name in the accent, the rest in grey; the line about the guide above the page.
|
|
title:SetPoint("TOPLEFT", f, "TOPLEFT", 16, -14)
|
|
title:SetText(ER.Skin.ACCENT .. "pfQuest xpGuide" .. END)
|
|
ER.Skin.Title(title, 14)
|
|
local ver = f:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall")
|
|
ver:SetPoint("LEFT", title, "RIGHT", 8, -1)
|
|
ver:SetText(GREY .. "settings v" .. ER.VERSION .. END)
|
|
S.sub:SetPoint("TOPLEFT", f, "TOPLEFT", S.side + LEFT, -36)
|
|
-- The sidebar: a darker strip with one flat button per page (Theme.lua turns them into OctoPad's buttons).
|
|
local side = f:CreateTexture(nil, "BACKGROUND")
|
|
S.sideTex = side
|
|
side:SetTexture("Interface\\Buttons\\WHITE8X8")
|
|
local th = ER.Skin.Theme()
|
|
side:SetVertexColor(th.side[1], th.side[2], th.side[3], 1)
|
|
side:SetPoint("TOPLEFT", f, "TOPLEFT", 1, -40)
|
|
side:SetPoint("BOTTOMLEFT", f, "BOTTOMLEFT", 1, 1)
|
|
side:SetWidth(S.side - 4)
|
|
for p, page in ipairs(PAGES) do
|
|
local tab = Button("pfQuest_xpGuideSettingsTab" .. p, f, { page.title, page.head, function() end }, S.side - 20)
|
|
tab:SetHeight(28)
|
|
tab:SetPoint("TOPLEFT", f, "TOPLEFT", 10, -50 - (p - 1) * 34)
|
|
tab.page = p
|
|
tab:SetScript("OnClick", function() ShowPage(this.page) end)
|
|
S.tabs[p] = tab
|
|
end
|
|
else
|
|
title:SetPoint("TOP", f, "TOP", 0, -18)
|
|
title:SetText("pfQuest xpGuide settings")
|
|
S.sub:SetPoint("TOP", title, "BOTTOM", 0, -6)
|
|
|
|
-- The page buttons along the top.
|
|
local tw = math.floor((W - 2 * LEFT - (count - 1) * 6) / count)
|
|
for p, page in ipairs(PAGES) do
|
|
local tab = Button("pfQuest_xpGuideSettingsTab" .. p, f, { page.title, page.head, function() end }, tw)
|
|
tab:SetPoint("TOPLEFT", f, "TOPLEFT", LEFT + (p - 1) * (tw + 6), -54)
|
|
-- six buttons in a row: the small font keeps "Configuration" inside its button
|
|
local label = getglobal("pfQuest_xpGuideSettingsTab" .. p .. "Text")
|
|
if label and label.SetFontObject and GameFontNormalSmall then label:SetFontObject(GameFontNormalSmall) end
|
|
tab.page = p
|
|
tab:SetScript("OnClick", function() ShowPage(this.page) end)
|
|
S.tabs[p] = tab
|
|
end
|
|
end
|
|
|
|
-- Every page is as tall as the tallest, so the window keeps one size while the pages change.
|
|
local tallest, nc, nb = 0, 0, 0
|
|
for p, page in ipairs(PAGES) do
|
|
local h
|
|
h, nc, nb = BuildPage(p, page, nc, nb)
|
|
if h > tallest then tallest = h end
|
|
end
|
|
for _, page in ipairs(S.pages) do page:SetHeight(tallest) end
|
|
-- Usage and Features fill the page: their boxes are as tall as what is left under the heading.
|
|
for _, view in ipairs(S.helpViews) do view:SetHeight(math.max(120, tallest - view.top - 8)) end
|
|
|
|
local bw = 120
|
|
for i, def in ipairs(BOTTOM) do
|
|
local b = Button("pfQuest_xpGuideSettingsBottom" .. i, f, def, bw)
|
|
b:SetPoint("BOTTOMLEFT", f, "BOTTOMLEFT", S.side + LEFT + (i - 1) * (bw + 8), 38)
|
|
end
|
|
|
|
local credit = f:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall")
|
|
credit:SetPoint("BOTTOMRIGHT", f, "BOTTOMRIGHT", -20, 16)
|
|
credit:SetText(GREY .. "pfQuest xpGuide v" .. ER.VERSION .. END)
|
|
local height = -S.top + tallest + 70 -- the bottom row and the credit line under the pages
|
|
if themed then height = math.max(height, 50 + count * 34 + 70) end -- room for the sidebar's buttons
|
|
f:SetHeight(height)
|
|
if ER.Skin then ER.Skin.Tree(f) end
|
|
f:SetScale(ER.SettingsScale(height, UIParent:GetHeight()))
|
|
end
|
|
|
|
function ER.ShowSettings(page)
|
|
if not S.frame then Build() end
|
|
if PageIndex(page) == PageIndex("Guides") then S.group, S.offset = nil, 0 end
|
|
Refresh()
|
|
ShowPage(page or Db().settingsPage or S.page or 1)
|
|
S.frame:Show()
|
|
end
|
|
|
|
-- The Guides page of the settings window (the guide menu lives there now).
|
|
function ER.ShowGuideMenu()
|
|
ER.ShowSettings("Guides")
|
|
end
|
|
|
|
-- The guide list follows the guide (GuideWindow.lua calls this when the steps change).
|
|
function ER.GuideMenuRefresh()
|
|
if S.frame and S.frame:IsShown() and S.FillGuides then S.FillGuides() end
|
|
end
|
|
|
|
function ER.SettingsShown()
|
|
return S.frame ~= nil and S.frame:IsShown() and true or false
|
|
end
|
|
|
|
function ER.ToggleSettings()
|
|
if S.frame and S.frame:IsShown() then S.frame:Hide() else ER.ShowSettings() end
|
|
end
|
|
|
|
ER.Loaded("Settings.lua")
|