LibAddonMenu-2.0.lua

--	LibAddonMenu-2.0 & its files © Ryan Lakanen (Seerah)		--
--	Distributed under The Artistic License 2.0 (see LICENSE)	--
------------------------------------------------------------------


--Register LAM with LibStub
local MAJOR, MINOR = "LibAddonMenu-2.0", 18
local lam, oldminor = LibStub:NewLibrary(MAJOR, MINOR)
if not lam then return end	--the same or newer version of this lib is already loaded into memory

local messages = {}
local MESSAGE_PREFIX = "[LAM2] "
local function PrintLater(msg)
	if CHAT_SYSTEM.primaryContainer then
		d(MESSAGE_PREFIX .. msg)
	else
		messages[#messages + 1] = msg
	end
end

local function FlushMessages()
	for i = 1, #messages do
		d(MESSAGE_PREFIX .. messages[i])
	end
	messages = {}
end

if LAMSettingsPanelCreated and not LAMCompatibilityWarning then
	PrintLater("An old version of LibAddonMenu with compatibility issues was detected. For more information on how to proceed search for LibAddonMenu on esoui.com")
	LAMCompatibilityWarning = true
end

--UPVALUES--
local wm = WINDOW_MANAGER
local em = EVENT_MANAGER
local sm = SCENE_MANAGER
local cm = CALLBACK_MANAGER
local tconcat = table.concat
local tinsert = table.insert

local addonsForList = {}
local addonToOptionsMap = {}
local optionsCreated = {}
lam.widgets = lam.widgets or {}
local widgets = lam.widgets
lam.util = {}
local util = lam.util

local function GetTooltipText(tooltip)
	if type(tooltip) == "string" then
		return tooltip
	elseif type(tooltip) == "function" then
		return tostring(tooltip())
	end
	return nil
end

local function CreateBaseControl(parent, controlData, controlName)
	local control = wm:CreateControl(controlName or controlData.reference, parent.scroll or parent, CT_CONTROL)
	control.panel = parent.panel or parent	-- if this is in a submenu, panel is the submenu's parent
	control.data = controlData

	control.isHalfWidth = controlData.width == "half"
	control:SetWidth(control.panel:GetWidth() - 60)
	return control
end

local MIN_HEIGHT = 26
local HALF_WIDTH_LINE_SPACING = 2
local function CreateLabelAndContainerControl(parent, controlData, controlName)
	local control = CreateBaseControl(parent, controlData, controlName)
	local width = control:GetWidth()

	local container = wm:CreateControl(nil, control, CT_CONTROL)
	container:SetDimensions(width / 3, MIN_HEIGHT)
	control.container = container

	local label = wm:CreateControl(nil, control, CT_LABEL)
	label:SetFont("ZoFontWinH4")
	label:SetHeight(MIN_HEIGHT)
	label:SetWrapMode(TEXT_WRAP_MODE_ELLIPSIS)
	label:SetText(controlData.name)
	control.label = label

	if control.isHalfWidth then
		control:SetDimensions(width / 2, MIN_HEIGHT * 2 + HALF_WIDTH_LINE_SPACING)
		label:SetAnchor(TOPLEFT, control, TOPLEFT, 0, 0)
		label:SetAnchor(TOPRIGHT, control, TOPRIGHT, 0, 0)
		container:SetAnchor(TOPRIGHT, control.label, BOTTOMRIGHT, 0, HALF_WIDTH_LINE_SPACING)
	else
		control:SetDimensions(width, MIN_HEIGHT)
		container:SetAnchor(TOPRIGHT, control, TOPRIGHT, 0, 0)
		label:SetAnchor(TOPLEFT, control, TOPLEFT, 0, 0)
		label:SetAnchor(TOPRIGHT, container, TOPLEFT, 5, 0)
	end

	control.data.tooltipText = GetTooltipText(control.data.tooltip)
	control:SetMouseEnabled(true)
	control:SetHandler("OnMouseEnter", ZO_Options_OnMouseEnter)
	control:SetHandler("OnMouseExit", ZO_Options_OnMouseExit)
	return control
end

util.GetTooltipText = GetTooltipText
util.CreateBaseControl = CreateBaseControl
util.CreateLabelAndContainerControl = CreateLabelAndContainerControl

local ADDON_DATA_TYPE = 1
local RESELECTING_DURING_REBUILD = true
local USER_REQUESTED_OPEN = true


--INTERNAL FUNCTION
--scrolls ZO_ScrollList `list` to move the row corresponding to `data`
--	into view (does nothing if there is no such row in the list)
--unlike ZO_ScrollList_ScrollDataIntoView, this function accounts for
--	fading near the list's edges - it avoids the fading area by scrolling
--	a little further than the ZO function
local function ScrollDataIntoView(list, data)
	local targetIndex = data.sortIndex
	if not targetIndex then return end

	local scrollMin, scrollMax = list.scrollbar:GetMinMax()
	local scrollTop = list.scrollbar:GetValue()
	local controlHeight = list.controlHeight
	local targetMin = controlHeight * (targetIndex - 1) - 64
	-- subtracting 64 ain't arbitrary, it's the maximum fading height
	-- (libraries/zo_templates/scrolltemplates.lua/UpdateScrollFade)

	if targetMin < scrollTop then
		ZO_ScrollList_ScrollAbsolute(list, zo_max(targetMin, scrollMin))
	else
		local listHeight = ZO_ScrollList_GetHeight(list)
		local targetMax = controlHeight * targetIndex + 64 - listHeight

		if targetMax > scrollTop then
			ZO_ScrollList_ScrollAbsolute(list, zo_min(targetMax, scrollMax))
		end
	end
end


--INTERNAL FUNCTION
--constructs a string pattern from the text in `searchEdit` control
--	* metacharacters are escaped, losing their special meaning
--	* whitespace matches anything (including empty substring)
--if there is nothing but whitespace, returns nil
--otherwise returns a filter function, which takes a `data` table argument
--	and returns true iff `data.filterText` matches the pattern
local function GetSearchFilterFunc(searchEdit)
	local text = searchEdit:GetText():lower()
	local pattern = text:match("(%S+.-)%s*$")

	if not pattern then -- nothing but whitespace
		return nil
	end

	-- escape metacharacters, e.g. "ESO-Datenbank.de" => "ESO%-Datenbank%.de"
	pattern = pattern:gsub("[-*+?^$().[%]%%]", "%%%0")

	-- replace whitespace with "match shortest anything"
	pattern = pattern:gsub("%s+", ".-")

	return function(data)
		return data.filterText:lower():find(pattern) ~= nil
	end
end


--INTERNAL FUNCTION
--populates `addonList` with entries from `addonsForList`
--	addonList = ZO_ScrollList control
--	filter = [optional] function(data)
local function PopulateAddonList(addonList, filter)
	local entryList = ZO_ScrollList_GetDataList(addonList)
	local numEntries = 0
	local selectedData = nil

	ZO_ScrollList_Clear(addonList)

	for i, data in ipairs(addonsForList) do
		if not filter or filter(data) then
			local dataEntry = ZO_ScrollList_CreateDataEntry(ADDON_DATA_TYPE, data)
			numEntries = numEntries + 1
			data.sortIndex = numEntries
			entryList[numEntries] = dataEntry
			-- select the first panel passing the filter, or the currently
			-- shown panel, but only if it passes the filter as well
			if selectedData == nil or data.panel == lam.currentAddonPanel then
				selectedData = data
			end
		else
			data.sortIndex = nil
		end
	end

	ZO_ScrollList_Commit(addonList)

	if selectedData then
		if selectedData.panel == lam.currentAddonPanel then
			ZO_ScrollList_SelectData(addonList, selectedData, nil, RESELECTING_DURING_REBUILD)
		else
			ZO_ScrollList_SelectData(addonList, selectedData, nil)
		end
		ScrollDataIntoView(addonList, selectedData)
	end
end


--METHOD: REGISTER WIDGET--
--each widget has its version checked before loading,
--so we only have the most recent one in memory
--Usage:
--	widgetType = "string"; the type of widget being registered
--	widgetVersion = integer; the widget's version number
LAMCreateControl = LAMCreateControl or {}
local lamcc = LAMCreateControl

function lam:RegisterWidget(widgetType, widgetVersion)
	if widgets[widgetType] and widgets[widgetType] >= widgetVersion then
		return false
	else
		widgets[widgetType] = widgetVersion
		return true
	end
end


--METHOD: OPEN TO ADDON PANEL--
--opens to a specific addon's option panel
--Usage:
--	panel = userdata; the panel returned by the :RegisterOptionsPanel method
local locSettings = GetString(SI_GAME_MENU_SETTINGS)
function lam:OpenToPanel(panel)

	-- find and select the panel's row in addon list

	local addonList = lam.addonList
	local selectedData = nil

	for _, addonData in ipairs(addonsForList) do
		if addonData.panel == panel then
			selectedData = addonData
			ScrollDataIntoView(addonList, selectedData)
			break
		end
	end

	ZO_ScrollList_SelectData(addonList, selectedData)
	ZO_ScrollList_RefreshVisible(addonList, selectedData)

	local srchEdit = LAMAddonSettingsWindow:GetNamedChild("SearchFilterEdit")
	srchEdit:Clear()

	-- note that ZO_ScrollList doesn't require `selectedData` to be actually
	-- present in the list, and that the list will only be populated once LAM
	-- "Addon Settings" menu entry is selected for the first time

	local function openAddonSettingsMenu()
		local gameMenu = ZO_GameMenu_InGame.gameMenu
		local settingsMenu = gameMenu.headerControls[locSettings]

		if settingsMenu then -- an instance of ZO_TreeNode
			local children = settingsMenu:GetChildren()
			for i = 1, (children and #children or 0) do
				local childNode = children[i]
				local data = childNode:GetData()
				if data and data.id == lam.panelId then
					-- found LAM "Addon Settings" node, yay!
					childNode:GetTree():SelectNode(childNode)
					break
				end
			end
		end
	end

	if sm:GetScene("gameMenuInGame"):GetState() == SCENE_SHOWN then
		openAddonSettingsMenu()
	else
		sm:CallWhen("gameMenuInGame", SCENE_SHOWN, openAddonSettingsMenu)
		sm:Show("gameMenuInGame")
	end
end


--INTERNAL FUNCTION
--creates controls when options panel is first shown
--controls anchoring of these controls in the panel
local function CreateOptionsControls(panel)
	local addonID = panel:GetName()
	local optionsTable = addonToOptionsMap[addonID]

	if optionsTable then
		local function CreateAndAnchorWidget(parent, widgetData, offsetX, offsetY, anchorTarget, wasHalf)
			local widget
			local status, err = pcall(function() widget = LAMCreateControl[widgetData.type](parent, widgetData) end)
			if not status then
				return err or true, offsetY, anchorTarget, wasHalf
			else
				local isHalf = (widgetData.width == "half")
				if not anchorTarget then -- the first widget in a panel is just placed in the top left corner
					widget:SetAnchor(TOPLEFT)
					anchorTarget = widget
				elseif wasHalf and isHalf then -- when the previous widget was only half width and this one is too, we place it on the right side
					widget:SetAnchor(TOPLEFT, anchorTarget, TOPRIGHT, 5 + (offsetX or 0), 0)
					widget.lineControl = anchorTarget
					offsetY = zo_max(0, widget:GetHeight() - anchorTarget:GetHeight()) -- we need to get the common height of both widgets to know where the next row starts
					isHalf = false
				else -- otherwise we just put it below the previous one normally
					widget:SetAnchor(TOPLEFT, anchorTarget, BOTTOMLEFT, 0, 15 + offsetY)
					offsetY = 0
					anchorTarget = widget
				end
				return false, offsetY, anchorTarget, isHalf
			end
		end

		local THROTTLE_TIMEOUT, THROTTLE_COUNT = 10, 20
		local fifo = {}
		local anchorOffset, lastAddedControl, wasHalf
		local CreateWidgetsInPanel, err

		local function PrepareForNextPanel()
			anchorOffset, lastAddedControl, wasHalf = 0, nil, false
		end

		local function SetupCreationCalls(parent, widgetDataTable)
			fifo[#fifo + 1] = PrepareForNextPanel
			local count = #widgetDataTable
			for i = 1, count, THROTTLE_COUNT do
				fifo[#fifo + 1] = function()
					CreateWidgetsInPanel(parent, widgetDataTable, i, zo_min(i + THROTTLE_COUNT - 1, count))
				end
			end
			return count ~= NonContiguousCount(widgetDataTable)
		end

		CreateWidgetsInPanel = function(parent, widgetDataTable, startIndex, endIndex)
			for i=startIndex,endIndex do
				local widgetData = widgetDataTable[i]
				if not widgetData then
					PrintLater("Skipped creation of missing entry in the settings menu of " .. addonID .. ".")
				else
					local widgetType = widgetData.type
					local offsetX = 0
					local isSubmenu = (widgetType == "submenu")
					if isSubmenu then
						wasHalf = false
						offsetX = 5
					end

					err, anchorOffset, lastAddedControl, wasHalf = CreateAndAnchorWidget(parent, widgetData, offsetX, anchorOffset, lastAddedControl, wasHalf)
					if err then
						PrintLater(("Could not create %s '%s' of %s."):format(widgetData.type, widgetData.name or "unnamed", addonID))
					end

					if isSubmenu then
						if SetupCreationCalls(lastAddedControl, widgetData.controls) then
							PrintLater(("The sub menu '%s' of %s is missing some entries."):format(widgetData.name or "unnamed", addonID))
						end
					end
				end
			end
		end

		local function DoCreateSettings()
			if #fifo > 0 then
				local nextCall = table.remove(fifo, 1)
				nextCall()
				if(nextCall == PrepareForNextPanel) then
					DoCreateSettings()
				else
					zo_callLater(DoCreateSettings, THROTTLE_TIMEOUT)
				end
			else
				optionsCreated[addonID] = true
				cm:FireCallbacks("LAM-PanelControlsCreated", panel)
			end
		end

		if SetupCreationCalls(panel, optionsTable) then
			PrintLater(("The settings menu of %s is missing some entries."):format(addonID))
		end
		DoCreateSettings()
	end
end


--INTERNAL FUNCTION
--handles switching between panels
local function ToggleAddonPanels(panel)	--called in OnShow of newly shown panel
	local currentlySelected = lam.currentAddonPanel
	if currentlySelected and currentlySelected ~= panel then
		currentlySelected:SetHidden(true)
	end
	lam.currentAddonPanel = panel

	-- refresh visible rows to reflect panel IsHidden status
	ZO_ScrollList_RefreshVisible(lam.addonList)

	if not optionsCreated[panel:GetName()] then	--if this is the first time opening this panel, create these options
		CreateOptionsControls(panel)
	end

	cm:FireCallbacks("LAM-RefreshPanel", panel)
end

local CheckSafetyAndInitialize

--METHOD: REGISTER ADDON PANEL
--registers your addon with LibAddonMenu and creates a panel
--Usage:
--	addonID = "string"; unique ID which will be the global name of your panel
--	panelData = table; data object for your panel - see controls\panel.lua
function lam:RegisterAddonPanel(addonID, panelData)
	CheckSafetyAndInitialize(addonID)
	local container = lam:GetAddonPanelContainer()
	local panel = lamcc.panel(container, panelData, addonID)	--addonID==global name of panel
	panel:SetHidden(true)
	panel:SetAnchorFill(container)
	panel:SetHandler("OnShow", ToggleAddonPanels)

	local function stripMarkup(str)
		return str:gsub("|[Cc]%x%x%x%x%x%x", ""):gsub("|[Rr]", "")
	end

	local filterParts = {panelData.name, nil, nil}
	-- append keywords and author separately, the may be nil
	filterParts[#filterParts + 1] = panelData.keywords
	filterParts[#filterParts + 1] = panelData.author

	local addonData = {
		panel = panel,
		name = stripMarkup(panelData.name),
		filterText = stripMarkup(tconcat(filterParts, "\t")):lower(),
	}

	tinsert(addonsForList, addonData)

	if panelData.slashCommand then
		SLASH_COMMANDS[panelData.slashCommand] = function()
			lam:OpenToPanel(panel)
		end
	end

	return panel	--return for authors creating options manually
end


--METHOD: REGISTER OPTION CONTROLS
--registers the options you want shown for your addon
--these are stored in a table where each key-value pair is the order
--of the options in the panel and the data for that control, respectively
--see exampleoptions.lua for an example
--see controls\<widget>.lua for each widget type
--Usage:
--	addonID = "string"; the same string passed to :RegisterAddonPanel
--	optionsTable = table; the table containing all of the options controls and their data
function lam:RegisterOptionControls(addonID, optionsTable)	--optionsTable = {sliderData, buttonData, etc}
	addonToOptionsMap[addonID] = optionsTable
end


--INTERNAL FUNCTION
--creates LAM's Addon Settings entry in ZO_GameMenu
local function CreateAddonSettingsMenuEntry()
	--Russian for TERAB1T's RuESO addon, which creates an "ru" locale
	--game font does not support Cyrillic, so they are using custom fonts + extended latin charset
	--Spanish provided by Luisen75 for their translation project
	local controlPanelNames = {
		en = "Addon Settings",
		fr = "Extensions",
		de = "Erweiterungen",
		ru = "Îacòpoéêè äoïoìîeîèé",
		es = "Configura Addons",
	}

	local panelData = {
		id = KEYBOARD_OPTIONS.currentPanelId,
		name = controlPanelNames[GetCVar("Language.2")] or controlPanelNames["en"],
	}

	KEYBOARD_OPTIONS.currentPanelId = panelData.id + 1
	KEYBOARD_OPTIONS.panelNames[panelData.id] = panelData.name

	lam.panelId = panelData.id

	local addonListSorted = false

	function panelData.callback()
		sm:AddFragment(lam:GetAddonSettingsFragment())
		KEYBOARD_OPTIONS:ChangePanels(lam.panelId)

		local title = LAMAddonSettingsWindow:GetNamedChild("Title")
		title:SetText(panelData.name)

		if not addonListSorted and #addonsForList > 0 then
			local searchEdit = LAMAddonSettingsWindow:GetNamedChild("SearchFilterEdit")
			--we're about to show our list for the first time - let's sort it
			table.sort(addonsForList, function(a, b) return a.name < b.name end)
			PopulateAddonList(lam.addonList, GetSearchFilterFunc(searchEdit))
			addonListSorted = true
		end
	end

	function panelData.unselectedCallback()
		sm:RemoveFragment(lam:GetAddonSettingsFragment())
		if SetCameraOptionsPreviewModeEnabled then -- available since API version 100011
			SetCameraOptionsPreviewModeEnabled(false)
		end
	end

	ZO_GameMenu_AddSettingPanel(panelData)
end


--INTERNAL FUNCTION
--creates the left-hand menu in LAM's window
local function CreateAddonList(name, parent)
	local addonList = wm:CreateControlFromVirtual(name, parent, "ZO_ScrollList")

	local function addonListRow_OnMouseDown(control, button)
		if button == 1 then
			local data = ZO_ScrollList_GetData(control)
			ZO_ScrollList_SelectData(addonList, data, control)
		end
	end

	local function addonListRow_OnMouseEnter(control)
		ZO_ScrollList_MouseEnter(addonList, control)
	end

	local function addonListRow_OnMouseExit(control)
		ZO_ScrollList_MouseExit(addonList, control)
	end

	local function addonListRow_Select(previouslySelectedData, selectedData, reselectingDuringRebuild)
		if not reselectingDuringRebuild then
			if previouslySelectedData then
				previouslySelectedData.panel:SetHidden(true)
			end
			if selectedData then
				selectedData.panel:SetHidden(false)
				PlaySound(SOUNDS.MENU_SUBCATEGORY_SELECTION)
			end
		end
	end

	local function addonListRow_Setup(control, data)
		control:SetText(data.name)
		control:SetSelected(not data.panel:IsHidden())
	end

	ZO_ScrollList_AddDataType(addonList, ADDON_DATA_TYPE, "ZO_SelectableLabel", 28, addonListRow_Setup)
	-- I don't know how to make highlights clear properly; they often
	-- get stuck and after a while the list is full of highlighted rows
	--ZO_ScrollList_EnableHighlight(addonList, "ZO_ThinListHighlight")
	ZO_ScrollList_EnableSelection(addonList, "ZO_ThinListHighlight", addonListRow_Select)

	local addonDataType = ZO_ScrollList_GetDataTypeTable(addonList, ADDON_DATA_TYPE)
	local addonListRow_CreateRaw = addonDataType.pool.m_Factory

	local function addonListRow_Create(pool)
		local control = addonListRow_CreateRaw(pool)
		control:SetHandler("OnMouseDown", addonListRow_OnMouseDown)
		--control:SetHandler("OnMouseEnter", addonListRow_OnMouseEnter)
		--control:SetHandler("OnMouseExit", addonListRow_OnMouseExit)
		control:SetHeight(28)
		control:SetFont("ZoFontHeader")
		control:SetHorizontalAlignment(TEXT_ALIGN_LEFT)
		control:SetVerticalAlignment(TEXT_ALIGN_CENTER)
		control:SetWrapMode(TEXT_WRAP_MODE_ELLIPSIS)
		return control
	end

	addonDataType.pool.m_Factory = addonListRow_Create

	return addonList
end


--INTERNAL FUNCTION
local function CreateSearchFilterBox(name, parent)
	local boxControl = wm:CreateControl(name, parent, CT_CONTROL)

	local srchButton =  wm:CreateControl("$(parent)Button", boxControl, CT_BUTTON)
	srchButton:SetDimensions(32, 32)
	srchButton:SetAnchor(LEFT, nil, LEFT, 2, 0)
	srchButton:SetNormalTexture("EsoUI/Art/LFG/LFG_tabIcon_groupTools_up.dds")
	srchButton:SetPressedTexture("EsoUI/Art/LFG/LFG_tabIcon_groupTools_down.dds")
	srchButton:SetMouseOverTexture("EsoUI/Art/LFG/LFG_tabIcon_groupTools_over.dds")

	local srchEdit = wm:CreateControlFromVirtual("$(parent)Edit", boxControl, "ZO_DefaultEdit")
	srchEdit:SetAnchor(LEFT, srchButton, RIGHT, 4, 1)
	srchEdit:SetAnchor(RIGHT, nil, RIGHT, -4, 1)
	srchEdit:SetColor(ZO_NORMAL_TEXT:UnpackRGBA())

	local srchBg = wm:CreateControl("$(parent)Bg", boxControl, CT_BACKDROP)
	srchBg:SetAnchorFill()
	srchBg:SetAlpha(0)
	srchBg:SetCenterColor(0, 0, 0, 0.5)
	srchBg:SetEdgeColor(ZO_DISABLED_TEXT:UnpackRGBA())
	srchBg:SetEdgeTexture("", 1, 1, 0, 0)

	-- search backdrop should appear whenever you hover over either
	-- the magnifying glass button or the edit field (which is only
	-- visible when it contains some text), and also while the edit
	-- field has keyboard focus

	local srchActive = false
	local srchHover = false

	local function srchBgUpdateAlpha()
		if srchActive or srchEdit:HasFocus() then
			srchBg:SetAlpha(srchHover and 0.8 or 0.6)
		else
			srchBg:SetAlpha(srchHover and 0.6 or 0.0)
		end
	end

	local function srchMouseEnter(control)
		srchHover = true
		srchBgUpdateAlpha()
	end

	local function srchMouseExit(control)
		srchHover = false
		srchBgUpdateAlpha()
	end

	boxControl:SetMouseEnabled(true)
	boxControl:SetHitInsets(1, 1, -1, -1)
	boxControl:SetHandler("OnMouseEnter", srchMouseEnter)
	boxControl:SetHandler("OnMouseExit", srchMouseExit)

	srchButton:SetHandler("OnMouseEnter", srchMouseEnter)
	srchButton:SetHandler("OnMouseExit", srchMouseExit)

	local focusLostTime = 0

	srchButton:SetHandler("OnClicked", function(self)
		srchEdit:Clear()
		if GetFrameTimeMilliseconds() - focusLostTime < 100 then
			-- re-focus the edit box if it lost focus due to this
			-- button click (note that this handler may run a few
			-- frames later)
			srchEdit:TakeFocus()
		end
	end)

	srchEdit:SetHandler("OnMouseEnter", srchMouseEnter)
	srchEdit:SetHandler("OnMouseExit", srchMouseExit)
	srchEdit:SetHandler("OnFocusGained", srchBgUpdateAlpha)

	srchEdit:SetHandler("OnFocusLost", function()
		focusLostTime = GetFrameTimeMilliseconds()
		srchBgUpdateAlpha()
	end)

	srchEdit:SetHandler("OnEscape", function(self)
		self:Clear()
		self:LoseFocus()
	end)

	srchEdit:SetHandler("OnTextChanged", function(self)
		local filterFunc = GetSearchFilterFunc(self)
		if filterFunc then
			srchActive = true
			srchBg:SetEdgeColor(ZO_SECOND_CONTRAST_TEXT:UnpackRGBA())
			srchButton:SetState(BSTATE_PRESSED)
		else
			srchActive = false
			srchBg:SetEdgeColor(ZO_DISABLED_TEXT:UnpackRGBA())
			srchButton:SetState(BSTATE_NORMAL)
		end
		srchBgUpdateAlpha()
		PopulateAddonList(lam.addonList, filterFunc)
		PlaySound(SOUNDS.SPINNER_DOWN)
	end)

	return boxControl
end


--INTERNAL FUNCTION
--creates LAM's Addon Settings top-level window
local function CreateAddonSettingsWindow()
	local tlw = wm:CreateTopLevelWindow("LAMAddonSettingsWindow")
	tlw:SetHidden(true)
	tlw:SetDimensions(1010, 914) -- same height as ZO_OptionsWindow

	ZO_ReanchorControlForLeftSidePanel(tlw)

	-- create black background for the window (mimic ZO_RightFootPrintBackground)

	local bgLeft = wm:CreateControl("$(parent)BackgroundLeft", tlw, CT_TEXTURE)
	bgLeft:SetTexture("EsoUI/Art/Miscellaneous/centerscreen_left.dds")
	bgLeft:SetDimensions(1024, 1024)
	bgLeft:SetAnchor(TOPLEFT, nil, TOPLEFT)
	bgLeft:SetDrawLayer(DL_BACKGROUND)
	bgLeft:SetExcludeFromResizeToFitExtents(true)

	local bgRight = wm:CreateControl("$(parent)BackgroundRight", tlw, CT_TEXTURE)
	bgRight:SetTexture("EsoUI/Art/Miscellaneous/centerscreen_right.dds")
	bgRight:SetDimensions(64, 1024)
	bgRight:SetAnchor(TOPLEFT, bgLeft, TOPRIGHT)
	bgRight:SetDrawLayer(DL_BACKGROUND)
	bgRight:SetExcludeFromResizeToFitExtents(true)

	-- create gray background for addon list (mimic ZO_TreeUnderlay)

	local underlayLeft = wm:CreateControl("$(parent)UnderlayLeft", tlw, CT_TEXTURE)
	underlayLeft:SetTexture("EsoUI/Art/Miscellaneous/centerscreen_indexArea_left.dds")
	underlayLeft:SetDimensions(256, 1024)
	underlayLeft:SetAnchor(TOPLEFT, bgLeft, TOPLEFT)
	underlayLeft:SetDrawLayer(DL_BACKGROUND)
	underlayLeft:SetExcludeFromResizeToFitExtents(true)

	local underlayRight = wm:CreateControl("$(parent)UnderlayRight", tlw, CT_TEXTURE)
	underlayRight:SetTexture("EsoUI/Art/Miscellaneous/centerscreen_indexArea_right.dds")
	underlayRight:SetDimensions(128, 1024)
	underlayRight:SetAnchor(TOPLEFT, underlayLeft, TOPRIGHT)
	underlayRight:SetDrawLayer(DL_BACKGROUND)
	underlayRight:SetExcludeFromResizeToFitExtents(true)

	-- create title bar (mimic ZO_OptionsWindow)

	local title = wm:CreateControl("$(parent)Title", tlw, CT_LABEL)
	title:SetAnchor(TOPLEFT, nil, TOPLEFT, 65, 70)
	title:SetFont("ZoFontWinH1")
	title:SetModifyTextType(MODIFY_TEXT_TYPE_UPPERCASE)

	local divider = wm:CreateControlFromVirtual("$(parent)Divider", tlw, "ZO_Options_Divider")
	divider:SetAnchor(TOPLEFT, nil, TOPLEFT, 65, 108)

	-- create search filter box

	local srchBox = CreateSearchFilterBox("$(parent)SearchFilter", tlw)
	srchBox:SetAnchor(TOPLEFT, nil, TOPLEFT, 63, 120)
	srchBox:SetDimensions(260, 30)

	-- create scrollable addon list

	local addonList = CreateAddonList("$(parent)AddonList", tlw)
	addonList:SetAnchor(TOPLEFT, nil, TOPLEFT, 65, 160)
	addonList:SetDimensions(285, 665)

	lam.addonList = addonList -- for easy access from elsewhere

	-- create container for option panels

	local panelContainer = wm:CreateControl("$(parent)PanelContainer", tlw, CT_CONTROL)
	panelContainer:SetAnchor(TOPLEFT, nil, TOPLEFT, 365, 120)
	panelContainer:SetDimensions(645, 675)

	return tlw
end


--INITIALIZING
local safeToInitialize = false
local hasInitialized = false

local eventHandle = table.concat({MAJOR, MINOR}, "r")
local function OnLoad(_, addonName)
	-- wait for the first loaded event
	em:UnregisterForEvent(eventHandle, EVENT_ADD_ON_LOADED)
	safeToInitialize = true
end
em:RegisterForEvent(eventHandle, EVENT_ADD_ON_LOADED, OnLoad)

local function OnActivated(_, addonName)
	em:UnregisterForEvent(eventHandle, EVENT_PLAYER_ACTIVATED)
	FlushMessages()
end
em:RegisterForEvent(eventHandle, EVENT_PLAYER_ACTIVATED, OnActivated)

function CheckSafetyAndInitialize(addonID)
	if not safeToInitialize then
		local msg = string.format("The panel with id '%s' was registered before addon loading has completed. This might break the AddOn Settings menu.", addonID)
		PrintLater(msg)
	end
	if not hasInitialized then
		hasInitialized = true
	end
end


--TODO documentation
function lam:GetAddonPanelContainer()
	local fragment = lam:GetAddonSettingsFragment()
	local window = fragment:GetControl()
	return window:GetNamedChild("PanelContainer")
end


--TODO documentation
function lam:GetAddonSettingsFragment()
	assert(hasInitialized or safeToInitialize)
	if not LAMAddonSettingsFragment then
		local window = CreateAddonSettingsWindow()
		LAMAddonSettingsFragment = ZO_FadeSceneFragment:New(window, true, 100)
		CreateAddonSettingsMenuEntry()
	end
	return LAMAddonSettingsFragment
end


-- vi: noexpandtab