UI.lua

-- Raid Locks - the panel.
--
-- Ledger layout: one row per lockout, sorted by what expires first. The row
-- reads in this order - instance name, time left, then difficulty, size and
-- boss pips underneath, with a hairline bar showing how much of the lock has
-- already burned off. Clicking a row opens its boss list, clicking a boss in
-- that list toggles it, for anything neither the server nor the combat log saw.

local ADDON, RaidLocks = ...

--------------------------------------------------------------------
-- Committed layout numbers
--------------------------------------------------------------------

local PANEL_W       = 360
local PANEL_PAD     = 10
local HEADER_H      = 52       -- title line plus the view tabs under it
local FOOTER_H      = 20
local ROW_H         = 40
local ROW_GAP       = 3
local BOSS_LINE_H   = 15
local MAX_LIST_H    = 9 * (ROW_H + ROW_GAP)

local PIP_SIZE      = 6
local PIP_GAP       = 3

-- Middle dot, written as UTF-8 bytes so it survives whatever the file is saved as.
local SEP           = "\194\183"

local FONT          = "Fonts\\FRIZQT__.TTF"
local FONT_NUM      = "Fonts\\ARIALN.TTF"
local SOLID         = "Interface\\Buttons\\WHITE8X8"

--------------------------------------------------------------------
-- Palette - one dark ground, one accent per difficulty, amber for urgency
--------------------------------------------------------------------

local C = {
	ground     = { 0.04, 0.05, 0.06, 0.94 },
	hairline   = { 0.28, 0.32, 0.38, 0.70 },
	rowBg      = { 0.085, 0.095, 0.115, 0.90 },
	rowHover   = { 0.135, 0.155, 0.185, 0.95 },
	track      = { 0.16, 0.17, 0.20, 0.90 },
	primary    = { 0.93, 0.94, 0.96 },
	secondary  = { 0.52, 0.56, 0.63 },
	dead       = { 0.34, 0.36, 0.40 },
	urgent     = { 0.98, 0.70, 0.25 },
	pipEmpty   = { 0.20, 0.22, 0.26 },
}

-- Ascension renames the raid difficulties, so match on the words rather than on
-- the difficulty index, and fall back to steel for anything unrecognised.
local DIFFICULTY_COLORS = {
	{ match = "mythic",   color = { 0.93, 0.51, 0.19 } },
	{ match = "ascended", color = { 0.36, 0.82, 0.74 } },
	{ match = "heroic",   color = { 0.65, 0.45, 0.90 } },
	{ match = "normal",   color = { 0.42, 0.57, 0.75 } },
}
local DIFFICULTY_FALLBACK = { 0.42, 0.57, 0.75 }

-- The second channel: what kind of content the lockout is. Kept desaturated
-- next to the difficulty colours so difficulty still wins the glance.
local KIND_COLORS = {
	raid      = { 0.58, 0.62, 0.70 },
	worldboss = { 0.86, 0.71, 0.33 },
	dungeon   = { 0.44, 0.64, 0.50 },
	openRaid  = { 0.45, 0.72, 0.56 },
	openBoss  = { 0.45, 0.72, 0.56 },
	-- One accent per expansion, so the open list reads as four short blocks
	-- instead of one long column. Kept in the same muted register as the rest.
	openVanilla = { 0.72, 0.62, 0.42 },
	openTbc     = { 0.48, 0.72, 0.44 },
	openWotlk   = { 0.46, 0.68, 0.82 },
	openCustom  = { 0.62, 0.55, 0.80 },
}

-- Expansion key -> the header kind that paints it.
local OPEN_EXPANSION_KIND = {
	vanilla = "openVanilla",
	tbc     = "openTbc",
	wotlk   = "openWotlk",
	custom  = "openCustom",
}

local KIND_LABELS = {
	raid      = "raid",
	worldboss = "world boss",
	dungeon   = "dungeon",
}

-- Kind is carried by the section headers the list is grouped under, which reads
-- far better than a slice of a 3px spine did. The spine is difficulty alone.
local KIND_ORDER = { "raid", "worldboss", "dungeon" }

local KIND_HEADINGS = {
	raid      = "RAID INSTANCES",
	worldboss = "WORLD BOSSES",
	dungeon   = "DUNGEONS",
	openRaid  = "STILL OPEN",
	openBoss  = "WORLD BOSSES STILL OPEN",
	openVanilla = "STILL OPEN " .. SEP .. " CLASSIC",
	openTbc     = "STILL OPEN " .. SEP .. " BURNING CRUSADE",
	openWotlk   = "STILL OPEN " .. SEP .. " WRATH OF THE LICH KING",
	openCustom  = "STILL OPEN " .. SEP .. " ASCENSION",
}

-- A world boss sitting in an expansion's open list still needs to read as a
-- world boss, so the name carries the kind the header no longer does.
local OPEN_NAME_COLORS = {
	raid      = { 0.62, 0.68, 0.62 },
	worldboss = { 0.86, 0.71, 0.33 },
}

-- The open lists are names only, two to a line, in a quieter colour than any
-- lockout: they are what is left, not what is spent.
local OPEN_LINE_H = 13
local OPEN_COLUMNS = 2

local HEADER_ROW_H = 22
local SPINE_W = 4

local function ColorHex(color)
	return string.format("ff%02x%02x%02x",
		math.floor(color[1] * 255), math.floor(color[2] * 255), math.floor(color[3] * 255))
end

local URGENT_BELOW = 12 * 3600

local function DifficultyColor(lock)
	local name = lock.difficultyName
	if name then
		local lower = string.lower(name)
		for _, entry in ipairs(DIFFICULTY_COLORS) do
			if string.find(lower, entry.match, 1, true) then return entry.color end
		end
	end
	return DIFFICULTY_FALLBACK
end

--------------------------------------------------------------------
-- Small builders
--------------------------------------------------------------------

local function Fill(parent, layer, color, blend)
	local tex = parent:CreateTexture(nil, layer or "BACKGROUND")
	tex:SetTexture(SOLID)
	if color then tex:SetVertexColor(color[1], color[2], color[3], color[4] or 1) end
	if blend then tex:SetBlendMode(blend) end
	return tex
end

local function Label(parent, font, size, flags, color)
	local text = parent:CreateFontString(nil, "OVERLAY")
	text:SetFont(font, size, flags)
	if color then text:SetTextColor(color[1], color[2], color[3]) end
	return text
end

--------------------------------------------------------------------
-- Panel
--------------------------------------------------------------------

local panel, content, scroll, rows, headers, openBlocks, historyRows, viewTabs, headerRight, footer
rows = {}
headers = {}
openBlocks = {}
historyRows = {}

local function SavePosition()
	local point, _, _, x, y = panel:GetPoint()
	local db = RaidLocks.db
	db.point, db.x, db.y = point, x, y
end

local function BuildPanel()
	panel = CreateFrame("Frame", "RaidLocksPanel", UIParent)
	panel:SetWidth(PANEL_W)
	panel:SetHeight(200)
	panel:SetFrameStrata("MEDIUM")
	panel:SetMovable(true)
	panel:EnableMouse(true)
	panel:SetClampedToScreen(true)
	panel:Hide()

	local bg = Fill(panel, "BACKGROUND", C.ground)
	bg:SetAllPoints(panel)

	-- A 1px lit edge along the top does the work a bevel would, for nothing.
	local edge = Fill(panel, "BORDER", C.hairline)
	edge:SetPoint("TOPLEFT", panel, "TOPLEFT", 0, 0)
	edge:SetPoint("TOPRIGHT", panel, "TOPRIGHT", 0, 0)
	edge:SetHeight(1)

	local title = Label(panel, FONT, 14, nil, C.primary)
	title:SetPoint("TOPLEFT", panel, "TOPLEFT", PANEL_PAD, -11)
	title:SetText("Raid Locks")

	headerRight = Label(panel, FONT, 11, nil, C.secondary)
	headerRight:SetPoint("TOPRIGHT", panel, "TOPRIGHT", -26, -13)

	-- Two views over the same panel: what is locked now, and what has already
	-- reset. A lockout that expires takes its record with it otherwise.
	local function ViewTab(text, view, anchor)
		local tab = CreateFrame("Button", nil, panel)
		tab:SetHeight(14)

		local label = Label(tab, FONT, 10, nil, C.secondary)
		label:SetPoint("LEFT", tab, "LEFT", 0, 0)
		label:SetText(text)
		tab.label = label

		local underline = Fill(tab, "ARTWORK", C.hairline)
		underline:SetPoint("TOPLEFT", label, "BOTTOMLEFT", 0, -2)
		underline:SetPoint("TOPRIGHT", label, "BOTTOMRIGHT", 0, -2)
		underline:SetHeight(1)
		tab.underline = underline

		-- The string width is only known once the font is laid out; before that
		-- it can be nil or 0, and a tab with no width is unclickable.
		local textWidth = label:GetStringWidth() or 0
		tab:SetWidth(textWidth > 0 and textWidth or 60)
		tab:SetPoint("TOPLEFT", anchor or panel, anchor and "TOPRIGHT" or "TOPLEFT",
			anchor and 14 or PANEL_PAD, anchor and 0 or -(HEADER_H - 22))

		tab:SetScript("OnClick", function()
			RaidLocks.db.view = view
			RaidLocks:Redraw()
		end)
		tab.view = view
		return tab
	end

	viewTabs = {}
	viewTabs[1] = ViewTab("LOCKOUTS", "locks", nil)
	viewTabs[2] = ViewTab("HISTORY", "history", viewTabs[1])

	local close = CreateFrame("Button", nil, panel)
	close:SetWidth(18)
	close:SetHeight(18)
	close:SetPoint("TOPRIGHT", panel, "TOPRIGHT", -6, -9)
	local closeText = Label(close, FONT, 14, nil, C.secondary)
	closeText:SetPoint("CENTER")
	closeText:SetText("x")
	close:SetScript("OnEnter", function() closeText:SetTextColor(unpack(C.primary)) end)
	close:SetScript("OnLeave", function() closeText:SetTextColor(unpack(C.secondary)) end)
	close:SetScript("OnClick", function() RaidLocks:Toggle() end)

	local headerRule = Fill(panel, "BORDER", { C.hairline[1], C.hairline[2], C.hairline[3], 0.35 })
	headerRule:SetPoint("TOPLEFT", panel, "TOPLEFT", PANEL_PAD, -(HEADER_H - 6))
	headerRule:SetPoint("TOPRIGHT", panel, "TOPRIGHT", -PANEL_PAD, -(HEADER_H - 6))
	headerRule:SetHeight(1)

	scroll = CreateFrame("ScrollFrame", "RaidLocksScroll", panel)
	scroll:SetPoint("TOPLEFT", panel, "TOPLEFT", PANEL_PAD, -HEADER_H)
	scroll:SetPoint("TOPRIGHT", panel, "TOPRIGHT", -PANEL_PAD, -HEADER_H)
	scroll:SetHeight(MAX_LIST_H)
	scroll:EnableMouseWheel(true)
	scroll:SetScript("OnMouseWheel", function(self, delta)
		local range = self.scrollRange or 0
		if range <= 0 then return end
		local target = self:GetVerticalScroll() - (delta * 40)
		if target < 0 then target = 0 end
		if target > range then target = range end
		self:SetVerticalScroll(target)
	end)

	content = CreateFrame("Frame", "RaidLocksContent", scroll)
	content:SetWidth(PANEL_W - PANEL_PAD * 2)
	content:SetHeight(1)
	scroll:SetScrollChild(content)

	footer = Label(panel, FONT, 10, nil, C.dead)
	footer:SetPoint("BOTTOMLEFT", panel, "BOTTOMLEFT", PANEL_PAD, 7)

	-- Drag anywhere on the panel body.
	panel:RegisterForDrag("LeftButton")
	panel:SetScript("OnDragStart", function(self) self:StartMoving() end)
	panel:SetScript("OnDragStop", function(self)
		self:StopMovingOrSizing()
		SavePosition()
	end)

	-- Only the clock needs redrawing between data changes, and only while the
	-- panel is on screen.
	panel.elapsed = 0
	panel:SetScript("OnUpdate", function(self, elapsed)
		self.elapsed = self.elapsed + elapsed
		if self.elapsed < 1 then return end
		self.elapsed = 0
		RaidLocks:UpdateClocks()
	end)
end

--------------------------------------------------------------------
-- Rows
--------------------------------------------------------------------

-- Section heading: the kind's colour, its name, how many are locked, and a rule
-- running out to the right edge so the eye can find the break while scrolling.
local function BuildHeader(index)
	local header = CreateFrame("Frame", nil, content)
	header:SetWidth(PANEL_W - PANEL_PAD * 2)
	header:SetHeight(HEADER_ROW_H)

	header.chip = Fill(header, "ARTWORK")
	header.chip:SetWidth(SPINE_W)
	header.chip:SetHeight(11)
	header.chip:SetPoint("BOTTOMLEFT", header, "BOTTOMLEFT", 0, 5)

	header.label = Label(header, FONT, 10, nil, C.secondary)
	header.label:SetPoint("BOTTOMLEFT", header.chip, "BOTTOMRIGHT", 6, -1)

	header.count = Label(header, FONT, 10, nil, C.dead)
	header.count:SetPoint("BOTTOMRIGHT", header, "BOTTOMRIGHT", 0, -1)

	header.rule = Fill(header, "BACKGROUND")
	header.rule:SetHeight(1)
	header.rule:SetPoint("BOTTOMLEFT", header.label, "BOTTOMRIGHT", 8, 4)
	header.rule:SetPoint("BOTTOMRIGHT", header.count, "BOTTOMLEFT", -8, 4)

	headers[index] = header
	RaidLocks.headers = headers
	return header
end

local function PaintHeader(header, kind, group, countText)
	local color = KIND_COLORS[kind] or KIND_COLORS.raid

	header.chip:SetVertexColor(color[1], color[2], color[3], 1)
	header.label:SetText(KIND_HEADINGS[kind] or "OTHER")
	header.label:SetTextColor(color[1], color[2], color[3])
	header.rule:SetVertexColor(color[1], color[2], color[3], 0.22)

	if countText then
		header.count:SetText(countText)
		return
	end

	local locked = 0
	for _, lock in ipairs(group) do
		if lock.locked then locked = locked + 1 end
	end
	header.count:SetText(locked > 0 and (locked .. " locked") or "all clear")
end

-- A block of instance names, two to a line. Cheaper than a row each, and the
-- point of this list is scanning it, not reading a clock off it.
local function BuildOpenBlock(index)
	local block = CreateFrame("Frame", nil, content)
	block:SetWidth(PANEL_W - PANEL_PAD * 2)
	block:SetHeight(OPEN_LINE_H)
	block.labels = {}
	openBlocks[index] = block
	RaidLocks.openBlocks = openBlocks
	return block
end

local function PaintOpenBlock(block, entries)
	local perColumn = math.ceil(#entries / OPEN_COLUMNS)
	local columnWidth = (PANEL_W - PANEL_PAD * 2) / OPEN_COLUMNS

	for i, entry in ipairs(entries) do
		local label = block.labels[i]
		if not label then
			label = Label(block, FONT, 9, nil, C.secondary)
			label:SetJustifyH("LEFT")
			block.labels[i] = label
		end

		local column = math.floor((i - 1) / perColumn)
		local slot = (i - 1) % perColumn
		label:ClearAllPoints()
		label:SetPoint("TOPLEFT", block, "TOPLEFT", 6 + column * columnWidth, -(slot * OPEN_LINE_H))
		label:SetWidth(columnWidth - 10)
		-- "Coilfang: Serpentshrine Cavern" is the cavern, and the prefix is what
		-- pushes the name past the column. " (PvE)" is a map-name artefact.
		local name = string.gsub(entry.name, "^[^:]+:%s*", "")
		name = string.gsub(name, "%s*%(PvE%)$", "")
		label:SetText(name)
		local color = OPEN_NAME_COLORS[entry.kind] or OPEN_NAME_COLORS.raid
		label:SetTextColor(color[1] * 0.85, color[2] * 0.85, color[3] * 0.85)
		label:Show()
	end

	for i = #entries + 1, #block.labels do
		block.labels[i]:Hide()
	end

	local height = math.max(perColumn * OPEN_LINE_H, OPEN_LINE_H)
	block:SetHeight(height)
	return height
end

-- History row: what was cleared, at what difficulty, how far it got, and how
-- long ago it reset. No clock and no pips - none of it is live any more.
local HISTORY_ROW_H = 26

local function BuildHistoryRow(index)
	local row = CreateFrame("Frame", nil, content)
	row:SetWidth(PANEL_W - PANEL_PAD * 2)
	row:SetHeight(HISTORY_ROW_H)

	row.bg = Fill(row, "BACKGROUND", { C.rowBg[1], C.rowBg[2], C.rowBg[3], 0.65 })
	row.bg:SetAllPoints(row)

	row.spine = Fill(row, "BORDER")
	row.spine:SetWidth(SPINE_W)
	row.spine:SetPoint("TOPLEFT", row, "TOPLEFT", 0, 0)
	row.spine:SetPoint("BOTTOMLEFT", row, "BOTTOMLEFT", 0, 0)

	row.name = Label(row, FONT, 11, nil, C.secondary)
	row.name:SetPoint("TOPLEFT", row, "TOPLEFT", 10, -4)

	row.meta = Label(row, FONT, 9, nil, C.dead)
	row.meta:SetPoint("TOPLEFT", row, "TOPLEFT", 10, -15)

	row.count = Label(row, FONT_NUM, 12, nil, C.secondary)
	row.count:SetPoint("TOPRIGHT", row, "TOPRIGHT", -2, -4)

	row.when = Label(row, FONT, 9, nil, C.dead)
	row.when:SetPoint("TOPRIGHT", row, "TOPRIGHT", -2, -15)

	historyRows[index] = row
	RaidLocks.historyRows = historyRows
	return row
end

local function PaintHistoryRow(row, entry)
	local color = DifficultyColor(entry)
	row.spine:SetVertexColor(color[1], color[2], color[3], 0.55)

	row.name:SetText(entry.name)

	local difficulty = entry.difficultyName and string.gsub(entry.difficultyName, "%s*%b()", "") or ""
	if entry.full then
		-- A full clear is the thing worth spotting in a list of half-runs.
		row.meta:SetText(string.format("|c%s%s|r  %s  |cff5cd18acleared|r",
			ColorHex(color), difficulty, SEP))
	else
		row.meta:SetText(string.format("|c%s%s|r", ColorHex(color), difficulty))
	end

	if entry.total and entry.total > 0 then
		row.count:SetText(entry.killed .. "/" .. entry.total)
	else
		row.count:SetText(tostring(entry.killed))
	end
	row.count:SetTextColor(color[1], color[2], color[3])

	row.when:SetText(RaidLocks:FormatAgo(entry.clearedAt))
end

local function BuildPips(row)
	row.pips = {}
	for i = 1, 24 do
		local pip = Fill(row, "ARTWORK", C.pipEmpty)
		pip:SetWidth(PIP_SIZE)
		pip:SetHeight(PIP_SIZE)
		pip:SetPoint("TOPRIGHT", row, "TOPRIGHT", -((i - 1) * (PIP_SIZE + PIP_GAP)), -24)
		pip:Hide()
		row.pips[i] = pip
	end

	-- One flash, moved to whichever pip just changed - bosses die one at a time.
	-- It is a frame because on this client only frames carry animation groups,
	-- and its texture blends additively so a kill reads as light arriving
	-- rather than as a colour swap.
	local flash = CreateFrame("Frame", nil, row)
	flash:SetWidth(PIP_SIZE + 6)
	flash:SetHeight(PIP_SIZE + 6)
	flash:SetPoint("CENTER", row, "TOPRIGHT", 0, 0)
	flash:SetAlpha(0)
	flash.tex = Fill(flash, "OVERLAY", { 1, 1, 1, 1 }, "ADD")
	flash.tex:SetAllPoints(flash)

	local group = flash:CreateAnimationGroup()
	local up = group:CreateAnimation("Alpha")
	up:SetChange(1)
	up:SetDuration(0.08)
	up:SetOrder(1)
	local down = group:CreateAnimation("Alpha")
	down:SetChange(-1)
	down:SetDuration(0.32)
	down:SetOrder(2)
	down:SetSmoothing("OUT")
	group:SetScript("OnFinished", function() flash:SetAlpha(0) end)

	row.flash = flash
	row.flashAnim = group
end

local function BossLine(row, index)
	local line = row.bossLines[index]
	if line then return line end

	line = CreateFrame("Button", nil, row.expand)
	line:SetHeight(BOSS_LINE_H)
	line:SetWidth((PANEL_W - PANEL_PAD * 2) / 2 - 8)

	line.mark = Fill(line, "ARTWORK", C.pipEmpty)
	line.mark:SetWidth(5)
	line.mark:SetHeight(5)
	line.mark:SetPoint("LEFT", line, "LEFT", 2, 0)

	line.right = Label(line, FONT_NUM, 11, nil, C.dead)
	line.right:SetPoint("RIGHT", line, "RIGHT", -4, 0)
	line.right:SetJustifyH("RIGHT")

	line.text = Label(line, FONT, 10, nil, C.secondary)
	line.text:SetPoint("LEFT", line.mark, "RIGHT", 5, 0)
	line.text:SetPoint("RIGHT", line.right, "LEFT", -4, 0)
	line.text:SetJustifyH("LEFT")

	-- The list is a readout, not a form: progress arrives from the server on
	-- zone-in and from the combat log during the run. Shift-click is left as a
	-- quiet override for the rare lockout neither source ever saw.
	line:SetScript("OnClick", function(self)
		local lock = row.lock
		if not lock or not self.boss or not IsShiftKeyDown() then return end
		RaidLocks:SetBossKilled(lock, self.boss, not lock.saved.bosses[self.boss])
	end)
	line:SetScript("OnEnter", function(self)
		if IsShiftKeyDown() then self.text:SetTextColor(unpack(C.primary)) end
	end)
	line:SetScript("OnLeave", function(self) RaidLocks:PaintBossLine(row, self) end)

	row.bossLines[index] = line
	return line
end

local function BuildRow(index)
	local row = CreateFrame("Button", "RaidLocksRow" .. index, content)
	row:SetWidth(PANEL_W - PANEL_PAD * 2)
	row:SetHeight(ROW_H)

	row.bg = Fill(row, "BACKGROUND", C.rowBg)
	row.bg:SetAllPoints(row)

	-- Difficulty as a spine down the left edge: colour instead of a legend.
	row.spine = Fill(row, "BORDER")
	row.spine:SetWidth(SPINE_W)
	row.spine:SetPoint("TOPLEFT", row, "TOPLEFT", 0, 0)
	row.spine:SetPoint("BOTTOMLEFT", row, "BOTTOMLEFT", 0, 0)

	-- and a wash of the same colour across the row, so difficulty is legible
	-- from the block of the row itself, not only from a 4px stripe.
	row.tint = Fill(row, "BORDER")
	row.tint:SetPoint("TOPLEFT", row.spine, "TOPRIGHT", 0, 0)
	row.tint:SetWidth(90)
	row.tint:SetPoint("BOTTOMLEFT", row.spine, "BOTTOMRIGHT", 0, 0)
	row.tint:SetTexture("Interface\\Buttons\\WHITE8X8")
	row.tint:SetBlendMode("ADD")

	row.name = Label(row, FONT, 13, nil, C.primary)
	row.name:SetPoint("TOPLEFT", row, "TOPLEFT", 10, -6)
	row.name:SetJustifyH("LEFT")

	row.time = Label(row, FONT_NUM, 16, "OUTLINE", C.primary)
	row.time:SetPoint("TOPRIGHT", row, "TOPRIGHT", -2, -5)
	row.time:SetJustifyH("RIGHT")

	row.meta = Label(row, FONT, 10, nil, C.secondary)
	row.meta:SetPoint("TOPLEFT", row, "TOPLEFT", 10, -22)
	row.meta:SetJustifyH("LEFT")

	row.progress = Label(row, FONT, 10, nil, C.secondary)
	row.progress:SetPoint("TOPRIGHT", row, "TOPRIGHT", -2, -22)
	row.progress:SetJustifyH("RIGHT")

	row.track = Fill(row, "ARTWORK", C.track)
	row.track:SetPoint("BOTTOMLEFT", row, "BOTTOMLEFT", 3, 3)
	row.track:SetPoint("BOTTOMRIGHT", row, "BOTTOMRIGHT", 0, 3)
	row.track:SetHeight(2)

	row.fill = Fill(row, "OVERLAY")
	row.fill:SetPoint("BOTTOMLEFT", row.track, "BOTTOMLEFT", 0, 0)
	row.fill:SetHeight(2)

	BuildPips(row)

	row.expand = CreateFrame("Frame", nil, row)
	row.expand:SetPoint("TOPLEFT", row, "BOTTOMLEFT", 10, -2)
	row.expand:SetPoint("TOPRIGHT", row, "BOTTOMRIGHT", 0, -2)
	row.expand:SetHeight(1)
	row.expand:Hide()
	row.bossLines = {}

	-- Where this row's boss state came from, so a wrong-looking list is
	-- explainable rather than mysterious.
	row.note = Label(row.expand, FONT, 9, nil, C.dead)
	row.note:SetPoint("BOTTOMLEFT", row.expand, "BOTTOMLEFT", 2, 1)

	row:SetScript("OnEnter", function(self)
		self.bg:SetVertexColor(unpack(C.rowHover))
	end)
	row:SetScript("OnLeave", function(self)
		self.bg:SetVertexColor(unpack(C.rowBg))
	end)
	row:RegisterForClicks("LeftButtonUp", "RightButtonUp")
	row:SetScript("OnClick", function(self, button)
		if not self.lock then return end
		if button == "RightButton" then
			RaidLocks:ShowRowMenu(self)
			return
		end
		local db = RaidLocks.db
		db.expanded = (db.expanded ~= self.lock.key) and self.lock.key or nil
		RaidLocks:Redraw()
	end)

	rows[index] = row
	return row
end

--------------------------------------------------------------------
-- Painting
--------------------------------------------------------------------

-- One line saying where this lockout's boss state came from.
function RaidLocks:SourceNote(lock, killed)
	if lock.source == "lockouts" then
		if lock.lootOnly then
			return "boss locks only - no instance save, so each boss clears on its own"
		end
		return "live from the server's loot lockouts"
	elseif lock.saved.source == "server" and lock.saved.capturedAt then
		return "read from the server on zone-in, " .. date("%d %b %H:%M", lock.saved.capturedAt)
	elseif lock.saved.source == "manual" then
		return "set by hand"
	elseif killed and killed > 0 then
		return "recorded from the combat log during the run"
	end
	return "no boss data yet - it fills in the moment you zone into the raid"
end

function RaidLocks:PaintBossLine(row, line)
	local lock = row.lock
	if not lock or not line.boss then return end
	local killed = self:IsBossKilled(lock, line.boss)
	local color = killed and DifficultyColor(lock) or C.pipEmpty
	line.mark:SetVertexColor(color[1], color[2], color[3], 1)
	if killed then
		line.text:SetTextColor(unpack(C.dead))
	else
		line.text:SetTextColor(unpack(C.secondary))
	end

	-- When bosses carry their own lock, say when this one comes back, but only
	-- where it differs from the row's own clock by more than a few minutes.
	local remaining = self:BossRemaining(lock, line.boss)
	if remaining and remaining > 0 and math.abs(remaining - (lock.reset or 0)) > 300 then
		line.right:SetText(self:FormatDuration(remaining))
		line.right:SetTextColor(color[1], color[2], color[3])
	else
		line.right:SetText("")
	end
end

-- Returns the width the pip block occupies, so the count text can sit clear of it.
local function PaintPips(row, lock)
	local roster = RaidLocks:RosterFor(lock)
	local color = DifficultyColor(lock)
	local count = roster and #roster or 0
	local fits = count > 0 and count <= #row.pips

	row.pipState = row.pipState or {}

	for i, pip in ipairs(row.pips) do
		if fits and i <= count then
			-- Pips run right to left, so the row keeps a flush right edge and
			-- the first boss of the raid sits leftmost.
			local boss = roster[count - i + 1]
			local killed = RaidLocks:IsBossKilled(lock, boss)
			if killed then
				pip:SetVertexColor(color[1], color[2], color[3], 1)
			else
				pip:SetVertexColor(C.pipEmpty[1], C.pipEmpty[2], C.pipEmpty[3], 1)
			end
			pip:Show()

			-- Flash only a pip that just turned over, never on a plain redraw.
			local was = row.pipState[i]
			if was == false and killed and row.flash then
				row.flashAnim:Stop()
				row.flash:ClearAllPoints()
				row.flash:SetPoint("CENTER", pip, "CENTER")
				row.flash.tex:SetVertexColor(color[1], color[2], color[3], 1)
				row.flashAnim:Play()
			end
			row.pipState[i] = killed
		else
			pip:Hide()
			row.pipState[i] = nil
		end
	end

	return fits and (count * (PIP_SIZE + PIP_GAP)) or 0
end

local function PaintRow(row, lock, expanded)
	row.lock = lock

	local color = DifficultyColor(lock)
	local urgent = lock.locked and lock.reset > 0 and lock.reset < URGENT_BELOW
	local dim = not lock.locked

	row.spine:SetVertexColor(color[1], color[2], color[3], dim and 0.35 or 1)

	local kind = RaidLocks:KindOf(lock)

	-- The wash carries the difficulty colour into the row and fades out, so the
	-- difficulty is readable from the row as a whole.
	row.tint:SetGradientAlpha("HORIZONTAL",
		color[1], color[2], color[3], dim and 0.05 or 0.16,
		color[1], color[2], color[3], 0)
	row.name:SetText(lock.name)
	row.name:SetTextColor(C.primary[1], C.primary[2], C.primary[3])

	if dim then
		row.time:SetText("expired")
		row.time:SetTextColor(unpack(C.dead))
	else
		row.time:SetText(RaidLocks:FormatDuration(lock.reset))
		if urgent then
			row.time:SetTextColor(unpack(C.urgent))
		else
			row.time:SetTextColor(unpack(C.primary))
		end
	end

	-- Meta line, coloured by what each part is: the difficulty in its own
	-- colour, size and reset clock in the quiet grey, an extended lock in the
	-- alarm colour because it is the one thing here that is unusual.
	local bits = {}
	if lock.difficultyName then
		-- "Mythic (10-25 Player)" is mostly the size, which the next field
		-- already carries, and the full string crowds the pips.
		local short = string.gsub(lock.difficultyName, "%s*%b()", "")
		bits[#bits + 1] = "|c" .. ColorHex(color) .. short .. "|r"
	end
	if lock.maxPlayers and lock.maxPlayers > 0 then
		bits[#bits + 1] = "|c" .. ColorHex(C.secondary) .. lock.maxPlayers .. " players|r"
	end
	if lock.locked and lock.reset > 0 then
		bits[#bits + 1] = "|c" .. ColorHex(C.dead) .. RaidLocks:FormatResetClock(lock.reset) .. "|r"
	end
	if lock.extended then
		bits[#bits + 1] = "|c" .. ColorHex(C.urgent) .. "extended|r"
	end
	row.meta:SetText(table.concat(bits, "|c" .. ColorHex(C.dead) .. "  " .. SEP .. "  |r"))

	local killed, total = RaidLocks:KillCount(lock)
	local roster = RaidLocks:RosterFor(lock)
	local pipWidth = PaintPips(row, lock)

	if total then
		row.progress:SetText(killed .. "/" .. total)
	else
		row.progress:SetText(killed > 0 and (killed .. " down") or "")
	end
	row.progress:ClearAllPoints()
	row.progress:SetPoint("TOPRIGHT", row, "TOPRIGHT", -(pipWidth > 0 and (pipWidth + 4) or 2), -22)
	if killed > 0 then
		row.progress:SetTextColor(color[1], color[2], color[3])
	else
		row.progress:SetTextColor(unpack(C.secondary))
	end

	-- The bar burns down over the whole lock, so a glance says how much of the
	-- week is gone without reading the number.
	local total_time = lock.saved.total or 0
	local fraction = 0
	if total_time > 0 and lock.locked then
		fraction = lock.reset / total_time
		if fraction > 1 then fraction = 1 elseif fraction < 0 then fraction = 0 end
	end
	local width = (PANEL_W - PANEL_PAD * 2 - 3) * fraction
	if width < 1 then width = 1 end
	row.fill:SetWidth(width)
	if urgent then
		row.fill:SetVertexColor(C.urgent[1], C.urgent[2], C.urgent[3], 0.95)
	else
		row.fill:SetVertexColor(color[1], color[2], color[3], dim and 0.25 or 0.75)
	end

	row:SetAlpha(dim and 0.55 or 1)

	-- Boss list
	if expanded and roster then
		local columns = 2
		local perColumn = math.ceil(#roster / columns)
		for i, boss in ipairs(roster) do
			local line = BossLine(row, i)
			local column = math.floor((i - 1) / perColumn)
			local slot = (i - 1) % perColumn
			line:ClearAllPoints()
			line:SetPoint("TOPLEFT", row.expand, "TOPLEFT",
				column * ((PANEL_W - PANEL_PAD * 2) / 2), -(slot * BOSS_LINE_H))
			line.boss = boss
			line.text:SetText(boss)
			RaidLocks:PaintBossLine(row, line)
			line:Show()
		end
		for i = #roster + 1, #row.bossLines do
			row.bossLines[i]:Hide()
		end

		row.note:SetText((KIND_LABELS[kind] or "raid") .. "  " .. SEP .. "  " .. RaidLocks:SourceNote(lock, killed))
		row.expand:SetHeight(perColumn * BOSS_LINE_H + 16)
		row.expand:Show()
		return ROW_H + perColumn * BOSS_LINE_H + 18
	end

	if expanded and not roster then
		local line = BossLine(row, 1)
		line:ClearAllPoints()
		line:SetPoint("TOPLEFT", row.expand, "TOPLEFT", 0, 0)
		line.boss = nil
		line.right:SetText("")
		line.text:SetText("No boss list for this instance yet.")
		line.text:SetTextColor(unpack(C.dead))
		line.mark:SetVertexColor(C.pipEmpty[1], C.pipEmpty[2], C.pipEmpty[3], 1)
		line:Show()
		for i = 2, #row.bossLines do row.bossLines[i]:Hide() end
		row.note:SetText("")
		row.expand:SetHeight(BOSS_LINE_H + 4)
		row.expand:Show()
		return ROW_H + BOSS_LINE_H + 6
	end

	for _, line in ipairs(row.bossLines) do line:Hide() end
	row.expand:Hide()
	return ROW_H
end

--------------------------------------------------------------------
-- Layout
--------------------------------------------------------------------

local function PaintViewTabs()
	if not viewTabs then return end
	local active = RaidLocks.db.view or "locks"
	for _, tab in ipairs(viewTabs) do
		if tab.view == active then
			tab.label:SetTextColor(unpack(C.primary))
			tab.underline:SetVertexColor(C.primary[1], C.primary[2], C.primary[3], 0.75)
		else
			tab.label:SetTextColor(unpack(C.dead))
			tab.underline:SetVertexColor(C.hairline[1], C.hairline[2], C.hairline[3], 0.15)
		end
	end
end

-- Everything already reset, newest first. This is the only place a cleared
-- lockout still exists: the server forgets it the moment it resets.
local function DrawHistory()
	local entries = RaidLocks:GetHistory()
	local offset = 0

	for index, entry in ipairs(entries) do
		local row = historyRows[index] or BuildHistoryRow(index)
		row:ClearAllPoints()
		row:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -offset)
		PaintHistoryRow(row, entry)
		row:Show()
		offset = offset + HISTORY_ROW_H + ROW_GAP
	end

	for index = #entries + 1, #historyRows do
		historyRows[index]:Hide()
	end

	for index = 1, #rows do
		rows[index]:Hide()
		rows[index].lock = nil
	end
	for index = 1, #headers do headers[index]:Hide() end
	for index = 1, #openBlocks do openBlocks[index]:Hide() end

	if #entries == 0 then
		footer:SetText("Nothing has reset yet - cleared lockouts land here when their week rolls over")
	else
		footer:SetText(#entries .. " past lockout" .. (#entries == 1 and "" or "s")
			.. "  " .. SEP .. "  right-click the minimap button to clear")
	end
	headerRight:SetText("what already reset")

	return offset
end

function RaidLocks:Redraw()
	if not panel then return end

	PaintViewTabs()

	if self.db.view == "history" then
		local used = DrawHistory()
		local listHeight = math.min(math.max(used, HISTORY_ROW_H), MAX_LIST_H)
		content:SetHeight(math.max(used, 1))
		scroll:SetHeight(listHeight)
		scroll.scrollRange = math.max(used - listHeight, 0)
		if scroll:GetVerticalScroll() > scroll.scrollRange then
			scroll:SetVerticalScroll(scroll.scrollRange)
		end
		panel:SetHeight(HEADER_H + listHeight + FOOTER_H)
		return
	end

	for index = 1, #historyRows do historyRows[index]:Hide() end

	local locks = self:VisibleLocks()
	local expandedKey = self.db.expanded
	local offset = 0

	-- Group the list under headings rather than mixing a world boss between two
	-- raids: scrolling should land you in a section, not in a soup.
	local grouped = {}
	for _, lock in ipairs(locks) do
		local kind = self:KindOf(lock)
		grouped[kind] = grouped[kind] or {}
		table.insert(grouped[kind], lock)
	end

	local rowIndex, headerIndex = 0, 0

	for _, kind in ipairs(KIND_ORDER) do
		local group = grouped[kind]
		if group and #group > 0 then
			headerIndex = headerIndex + 1
			local header = headers[headerIndex] or BuildHeader(headerIndex)
			header:ClearAllPoints()
			header:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -offset)
			PaintHeader(header, kind, group)
			header:Show()
			offset = offset + HEADER_ROW_H

			for _, lock in ipairs(group) do
				rowIndex = rowIndex + 1
				local row = rows[rowIndex] or BuildRow(rowIndex)
				row:ClearAllPoints()
				row:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -offset)
				row:Show()
				local used = PaintRow(row, lock, expandedKey == lock.key)
				offset = offset + used + ROW_GAP
			end

			offset = offset + 6
		end
	end

	-- What is still open, at the bottom: everything with no lock on it at all.
	local blockIndex = 0
	if self.db.showOpen then
		for _, group in ipairs(self:OpenByExpansion()) do
			local kind = OPEN_EXPANSION_KIND[group.key] or "openCustom"
			local entries = group.entries

			headerIndex = headerIndex + 1
			local header = headers[headerIndex] or BuildHeader(headerIndex)
			header:ClearAllPoints()
			header:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -offset)
			PaintHeader(header, kind, nil, #entries .. " open")
			header:Show()
			offset = offset + HEADER_ROW_H

			blockIndex = blockIndex + 1
			local block = openBlocks[blockIndex] or BuildOpenBlock(blockIndex)
			block:ClearAllPoints()
			block:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -offset)
			block:Show()
			offset = offset + PaintOpenBlock(block, entries) + 8
		end
	end

	for index = rowIndex + 1, #rows do
		rows[index]:Hide()
		rows[index].lock = nil
	end
	for index = headerIndex + 1, #headers do
		headers[index]:Hide()
	end
	for index = blockIndex + 1, #openBlocks do
		openBlocks[index]:Hide()
	end

	content:SetHeight(math.max(offset, 1))

	local listHeight = math.min(offset, MAX_LIST_H)
	if listHeight < ROW_H then listHeight = ROW_H end
	scroll:SetHeight(listHeight)
	scroll.scrollRange = math.max(offset - listHeight, 0)
	if scroll:GetVerticalScroll() > scroll.scrollRange then
		scroll:SetVerticalScroll(scroll.scrollRange)
	end

	panel:SetHeight(HEADER_H + listHeight + FOOTER_H)

	-- Header: who this is, and what falls off next.
	local soonest
	for _, lock in ipairs(locks) do
		if lock.locked and lock.reset > 0 and (not soonest or lock.reset < soonest) then
			soonest = lock.reset
		end
	end
	local lockedCount = 0
	for _, lock in ipairs(locks) do
		if lock.locked then lockedCount = lockedCount + 1 end
	end
	if soonest then
		headerRight:SetText(string.format("%d locked  %s  next in %s",
			lockedCount, SEP, self:FormatDuration(soonest)))
	else
		headerRight:SetText(#locks > 0 and "nothing locked" or "no lockouts")
	end

	if #locks == 0 then
		footer:SetText("No saved instances. Right-click the minimap button for options.")
	else
		footer:SetText("Click a raid for its bosses  " .. SEP .. "  progress fills itself in when you zone in")
	end
end

-- Cheap per-second pass: only the numbers that actually move.
function RaidLocks:UpdateClocks()
	if not panel or not panel:IsShown() then return end
	for _, row in ipairs(rows) do
		local lock = row.lock
		if lock and row:IsShown() and lock.locked then
			lock.reset = math.max((lock.reset or 0) - 1, 0)
			row.time:SetText(self:FormatDuration(lock.reset))
			local total = lock.saved.total or 0
			if total > 0 then
				local fraction = math.max(math.min(lock.reset / total, 1), 0)
				local width = (PANEL_W - PANEL_PAD * 2 - 3) * fraction
				row.fill:SetWidth(width < 1 and 1 or width)
			end
			if lock.reset < URGENT_BELOW then
				row.time:SetTextColor(unpack(C.urgent))
			end
		end
	end
end

function RaidLocks:OnDataChanged()
	self:Redraw()
end

--------------------------------------------------------------------
-- Show / hide
--------------------------------------------------------------------

function RaidLocks:Show()
	if not panel then return end
	panel:ClearAllPoints()
	panel:SetPoint(self.db.point or "CENTER", UIParent, self.db.point or "CENTER", self.db.x or 0, self.db.y or 0)
	-- No fade-in here. An Alpha animation group on this client restores the
	-- frame's pre-animation alpha when it finishes, and it does that after
	-- OnFinished runs, so the panel played its fade and then went invisible.
	panel:SetAlpha(1)
	panel:Show()
	self.db.shown = true
	-- Restoring a panel that was open last session happens at ADDON_LOADED,
	-- which is before the player object exists. Asking the client for lockouts
	-- there crashes it outright, so an early show paints from saved data only
	-- and the login events do the refresh.
	if self:IsWorldReady() then
		self:Refresh()
		-- Opening the panel inside an instance is a free chance to catch the
		-- lock query if the zone-in poll missed it.
		if IsInInstance() then self:CaptureLockDetail() end
	end
	self:Redraw()
end

function RaidLocks:Hide()
	if not panel then return end
	panel:Hide()
	self.db.shown = false
end

function RaidLocks:Toggle()
	if panel and panel:IsShown() then self:Hide() else self:Show() end
end

--------------------------------------------------------------------
-- Menus
--------------------------------------------------------------------

local menuFrame

local function AddTitle(text, level)
	local info = UIDropDownMenu_CreateInfo()
	info.text = text
	info.isTitle = true
	info.notCheckable = true
	UIDropDownMenu_AddButton(info, level)
end

local rowMenuLock

local function InitializeRowMenu(self, level)
	if not level or not rowMenuLock then return end
	local lock = rowMenuLock

	AddTitle(lock.name, level)

	local roster = RaidLocks:RosterFor(lock)

	-- Nothing to correct when the server is reporting the bosses itself.
	if lock.source == "lockouts" then
		AddTitle("Boss locks come from the server", level)
		return
	end

	local info = UIDropDownMenu_CreateInfo()
	info.text = "Mark every boss killed"
	info.notCheckable = true
	info.disabled = not roster
	info.func = function()
		if not roster then return end
		for _, boss in ipairs(roster) do lock.saved.bosses[boss] = true end
		lock.saved.source = "manual"
		RaidLocks:Redraw()
		CloseDropDownMenus()
	end
	UIDropDownMenu_AddButton(info, level)

	info = UIDropDownMenu_CreateInfo()
	info.text = "Clear boss progress"
	info.notCheckable = true
	info.func = function()
		lock.saved.bosses = {}
		lock.saved.source = "manual"
		RaidLocks:Redraw()
		CloseDropDownMenus()
	end
	UIDropDownMenu_AddButton(info, level)

	if lock.saved.source == "server" and lock.saved.capturedAt then
		AddTitle("From the server " .. date("%d/%m %H:%M", lock.saved.capturedAt), level)
	end
end

function RaidLocks:ShowRowMenu(row)
	rowMenuLock = row.lock
	if not menuFrame then
		menuFrame = CreateFrame("Frame", "RaidLocksMenu", UIParent, "UIDropDownMenuTemplate")
	end
	UIDropDownMenu_Initialize(menuFrame, InitializeRowMenu, "MENU")
	ToggleDropDownMenu(1, nil, menuFrame, "cursor", 0, 0)
end

local function InitializeMainMenu(self, level)
	if not level then return end
	local db = RaidLocks.db

	AddTitle("Raid Locks", level)

	local info = UIDropDownMenu_CreateInfo()
	info.text = "Raids only"
	info.checked = db.raidsOnly
	info.keepShownOnClick = true
	info.func = function()
		db.raidsOnly = not db.raidsOnly
		RaidLocks:Redraw()
	end
	UIDropDownMenu_AddButton(info, level)

	info = UIDropDownMenu_CreateInfo()
	info.text = "Clear the history"
	info.notCheckable = true
	info.disabled = #RaidLocks:GetHistory() == 0
	info.func = function()
		RaidLocks:ClearHistory()
		CloseDropDownMenus()
	end
	UIDropDownMenu_AddButton(info, level)

	info = UIDropDownMenu_CreateInfo()
	info.text = "Show what is still open"
	info.checked = db.showOpen
	info.keepShownOnClick = true
	info.func = function()
		db.showOpen = not db.showOpen
		RaidLocks:Redraw()
	end
	UIDropDownMenu_AddButton(info, level)

	info = UIDropDownMenu_CreateInfo()
	info.text = "Record boss kills from the combat log"
	info.checked = db.autoRecord
	info.keepShownOnClick = true
	info.func = function() db.autoRecord = not db.autoRecord end
	UIDropDownMenu_AddButton(info, level)

	AddTitle("Sort", level)

	info = UIDropDownMenu_CreateInfo()
	info.text = "By time left"
	info.checked = db.sort ~= "name"
	info.func = function()
		db.sort = "time"
		RaidLocks:Scan()
		CloseDropDownMenus()
	end
	UIDropDownMenu_AddButton(info, level)

	info = UIDropDownMenu_CreateInfo()
	info.text = "By name"
	info.checked = db.sort == "name"
	info.func = function()
		db.sort = "name"
		RaidLocks:Scan()
		CloseDropDownMenus()
	end
	UIDropDownMenu_AddButton(info, level)
end

local function ShowMainMenu()
	if not menuFrame then
		menuFrame = CreateFrame("Frame", "RaidLocksMenu", UIParent, "UIDropDownMenuTemplate")
	end
	UIDropDownMenu_Initialize(menuFrame, InitializeMainMenu, "MENU")
	ToggleDropDownMenu(1, nil, menuFrame, "cursor", 0, 0)
end

--------------------------------------------------------------------
-- Minimap button
--------------------------------------------------------------------

local function SetupMinimapButton()
	local LDB = LibStub and LibStub("LibDataBroker-1.1", true)
	local LDBIcon = LibStub and LibStub("LibDBIcon-1.0", true)
	if not (LDB and LDBIcon) then
		RaidLocks:Print("minimap button unavailable: LibDataBroker/LibDBIcon did not load.")
		return
	end

	local launcher = LDB:NewDataObject(ADDON, {
		type = "launcher",
		text = "Raid Locks",
		icon = "Interface\\Icons\\INV_Misc_PocketWatch_01",
		OnClick = function(_, button)
			if button == "RightButton" then
				ShowMainMenu()
			else
				RaidLocks:Toggle()
			end
		end,
		OnTooltipShow = function(tooltip)
			tooltip:AddLine("Raid Locks")
			local locks = RaidLocks:VisibleLocks()
			local shown = 0
			for _, lock in ipairs(locks) do
				if lock.locked and shown < 5 then
					shown = shown + 1
					local killed, total = RaidLocks:KillCount(lock)
					local progress = total and (killed .. "/" .. total) or tostring(killed)
					tooltip:AddDoubleLine(
						lock.name .. " |cff808080" .. (lock.difficultyName or "") .. "|r",
						progress .. "   " .. RaidLocks:FormatDuration(lock.reset),
						0.9, 0.9, 0.9, 0.65, 0.7, 0.78)
				end
			end
			if shown == 0 then
				tooltip:AddLine("No active lockouts", 0.6, 0.6, 0.6)
			end
			tooltip:AddLine(" ")
			-- What the two halves of a row's spine mean, since the panel
			-- itself carries no legend.
			tooltip:AddLine("Spine, top: |cff94a0b3raid|r  |cffdbb554world boss|r  |cff70a380dungeon|r", 0.7, 0.7, 0.7)
			tooltip:AddLine("Spine, bottom: |cff6b91bfNormal|r  |cffa673e6Heroic|r  |cffee8230Mythic|r  |cff5cd1bdAscended|r", 0.7, 0.7, 0.7)
			tooltip:AddLine(" ")
			tooltip:AddLine("|cffffffffLeft-click|r opens the panel", 0.7, 0.7, 0.7)
			tooltip:AddLine("|cffffffffRight-click|r for options", 0.7, 0.7, 0.7)
		end,
	})

	RaidLocks.db.minimap.hide = false
	LDBIcon:Register(ADDON, launcher, RaidLocks.db.minimap)
end

--------------------------------------------------------------------
-- Slash commands
--------------------------------------------------------------------

local function HandleSlash(input)
	input = string.lower(string.gsub(input or "", "^%s*(.-)%s*$", "%1"))

	if input == "refresh" then
		RaidLocks:Refresh()
		RaidLocks:Print("asked the server for a fresh lockout list.")
		return
	elseif input == "raids" then
		RaidLocks.db.raidsOnly = true
		RaidLocks:Redraw()
		RaidLocks:Print("showing raids only.")
		return
	elseif input == "all" then
		RaidLocks.db.raidsOnly = false
		RaidLocks:Redraw()
		RaidLocks:Print("showing every saved instance.")
		return
	elseif input == "help" then
		RaidLocks:Print("/raidlocks - open or close the panel")
		RaidLocks:Print("/raidlocks raids | all - filter the list")
		RaidLocks:Print("/raidlocks refresh - re-ask the server")
		return
	end

	RaidLocks:Toggle()
end

--------------------------------------------------------------------
-- Startup
--------------------------------------------------------------------

function RaidLocks:OnDatabaseReady()
	BuildPanel()
	SetupMinimapButton()
	self:Scan()
	if self.db.shown then
		self:Show()
	end

	SLASH_RAIDLOCKS1 = "/raidlocks"
	SLASH_RAIDLOCKS2 = "/rl"
	SlashCmdList["RAIDLOCKS"] = HandleSlash
end