Cinecom
1552 lines
61 KiB
Lua
1552 lines
61 KiB
Lua
-- ConsumesTracker.lua
|
|
|
|
-- Metadata -------------------------------------------------------------------------------------------
|
|
AddonName = "Consumes Tracker"
|
|
Version = "1.4"
|
|
VState = "multi character (beta)"
|
|
WindowWidth = 310
|
|
|
|
-- Onload & Click/Drag Functionality ------------------------------------------------------------------
|
|
function ConsumesTracker_OnLoad(self)
|
|
self:RegisterForDrag("LeftButton")
|
|
self:SetScript("OnDragStart", function() ConsumesTracker_OnDragStart(self) end)
|
|
self:SetScript("OnDragStop", function() ConsumesTracker_OnDragStop(self) end)
|
|
DEFAULT_CHAT_FRAME:AddMessage("|cff00ff00" .. AddonName .. " Loaded! (version " .. Version .. "-" .. VState .. ")|r |cff808080[Made by Horyoshi]|r")
|
|
end
|
|
|
|
-- Click Handling -------------------------------------------------------------------------------------
|
|
function ConsumesTracker_HandleClick(self, button)
|
|
if not self then return end
|
|
if button == "LeftButton" and not IsShiftKeyDown() then
|
|
if ConsumeTracker_MainFrame and ConsumeTracker_MainFrame:IsShown() then
|
|
ConsumeTracker_MainFrame:Hide()
|
|
else
|
|
ConsumeTracker_ShowMainWindow()
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Drag Functions -------------------------------------------------------------------------------------
|
|
function ConsumesTracker_OnDragStart(self)
|
|
if IsShiftKeyDown() then
|
|
self:StartMoving()
|
|
self.isMoving = true
|
|
end
|
|
end
|
|
|
|
function ConsumesTracker_OnDragStop(self)
|
|
if self and self.isMoving then
|
|
self:StopMovingOrSizing()
|
|
self.isMoving = false
|
|
end
|
|
end
|
|
|
|
-- Initialize SavedVariables ----------------------------------------------------------------------------
|
|
if not ConsumeTracker_Settings then
|
|
ConsumeTracker_Settings = {}
|
|
end
|
|
if not ConsumeTracker_Data then
|
|
ConsumeTracker_Data = {}
|
|
end
|
|
|
|
-- Event frame for updating data ----------------------------------------------------------------------
|
|
local ConsumeTracker_EventFrame = CreateFrame("Frame")
|
|
ConsumeTracker_EventFrame:RegisterEvent("PLAYER_LOGIN")
|
|
ConsumeTracker_EventFrame:RegisterEvent("BAG_UPDATE")
|
|
ConsumeTracker_EventFrame:RegisterEvent("BANKFRAME_OPENED")
|
|
ConsumeTracker_EventFrame:RegisterEvent("PLAYERBANKSLOTS_CHANGED")
|
|
ConsumeTracker_EventFrame:RegisterEvent("ITEM_LOCK_CHANGED")
|
|
ConsumeTracker_EventFrame:RegisterEvent("MAIL_SHOW")
|
|
ConsumeTracker_EventFrame:RegisterEvent("MAIL_INBOX_UPDATE")
|
|
ConsumeTracker_EventFrame:RegisterEvent("MAIL_CLOSED")
|
|
|
|
ConsumeTracker_EventFrame:SetScript("OnEvent", function()
|
|
if event == "PLAYER_LOGIN" then
|
|
ConsumeTracker_ScanPlayerInventory()
|
|
ConsumeTracker_ScanPlayerBank()
|
|
ConsumeTracker_ScanPlayerMail()
|
|
elseif event == "BAG_UPDATE" then
|
|
ConsumeTracker_ScanPlayerInventory()
|
|
if BankFrame and BankFrame:IsShown() then
|
|
ConsumeTracker_ScanPlayerBank()
|
|
end
|
|
if MailFrame and MailFrame:IsShown() then
|
|
ConsumeTracker_ScanPlayerMail()
|
|
end
|
|
elseif event == "BANKFRAME_OPENED" then
|
|
ConsumeTracker_ScanPlayerBank()
|
|
elseif event == "PLAYERBANKSLOTS_CHANGED" then
|
|
ConsumeTracker_ScanPlayerBank()
|
|
ConsumeTracker_ScanPlayerInventory()
|
|
elseif event == "ITEM_LOCK_CHANGED" then
|
|
if BankFrame and BankFrame:IsShown() then
|
|
ConsumeTracker_ScanPlayerInventory()
|
|
ConsumeTracker_ScanPlayerBank()
|
|
end
|
|
if MailFrame and MailFrame:IsShown() then
|
|
ConsumeTracker_ScanPlayerInventory()
|
|
ConsumeTracker_ScanPlayerMail()
|
|
end
|
|
elseif event == "MAIL_SHOW" or event == "MAIL_INBOX_UPDATE" then
|
|
ConsumeTracker_ScanPlayerMail()
|
|
end
|
|
end)
|
|
|
|
|
|
|
|
function ConsumeTracker_CreateMainWindow()
|
|
-- Main Frame
|
|
ConsumeTracker_MainFrame = CreateFrame("Frame", "ConsumeTracker_MainFrame", UIParent)
|
|
ConsumeTracker_MainFrame:SetWidth(WindowWidth)
|
|
ConsumeTracker_MainFrame:SetHeight(512)
|
|
ConsumeTracker_MainFrame:SetPoint("CENTER", UIParent, "CENTER")
|
|
ConsumeTracker_MainFrame:SetFrameStrata("DIALOG")
|
|
ConsumeTracker_MainFrame:SetMovable(true)
|
|
ConsumeTracker_MainFrame:EnableMouse(true)
|
|
ConsumeTracker_MainFrame:RegisterForDrag("LeftButton")
|
|
ConsumeTracker_MainFrame:SetScript("OnDragStart", function()
|
|
this:StartMoving()
|
|
end)
|
|
ConsumeTracker_MainFrame:SetScript("OnDragStop", function()
|
|
this:StopMovingOrSizing()
|
|
end)
|
|
|
|
table.insert(UISpecialFrames, "ConsumeTracker_MainFrame")
|
|
|
|
-- Background Texture
|
|
local background = ConsumeTracker_MainFrame:CreateTexture(nil, "BACKGROUND")
|
|
background:SetTexture("Interface\\DialogFrame\\UI-DialogBox-Background")
|
|
background:SetPoint("TOPLEFT", ConsumeTracker_MainFrame, "TOPLEFT", 12, -12)
|
|
background:SetPoint("BOTTOMRIGHT", ConsumeTracker_MainFrame, "BOTTOMRIGHT", -12, 12)
|
|
|
|
-- Border
|
|
ConsumeTracker_MainFrame:SetBackdrop({
|
|
bgFile = "Interface\\Tooltips\\UI-Tooltip-Background",
|
|
edgeFile = "Interface\\DialogFrame\\UI-DialogBox-Border",
|
|
tile = true, tileSize = 32, edgeSize = 32,
|
|
insets = { left = 11, right = 12, top = 12, bottom = 11 }
|
|
})
|
|
ConsumeTracker_MainFrame:SetBackdropColor(0.1, 0.1, 0.1, 1)
|
|
|
|
-- Title Text
|
|
local titleText = ConsumeTracker_MainFrame:CreateFontString(nil, "OVERLAY", "GameFontNormalLarge")
|
|
titleText:SetText(AddonName)
|
|
titleText:SetPoint("TOP", ConsumeTracker_MainFrame, "TOP", 0, -2)
|
|
|
|
-- Calculate the width of the title text and adjust the title background accordingly
|
|
local titleWidth = titleText:GetStringWidth() + 160
|
|
|
|
-- Title Background
|
|
local titleBg = ConsumeTracker_MainFrame:CreateTexture(nil, "ARTWORK")
|
|
titleBg:SetTexture("Interface\\DialogFrame\\UI-DialogBox-Header")
|
|
titleBg:SetWidth(titleWidth)
|
|
titleBg:SetHeight(64)
|
|
titleBg:SetPoint("TOP", ConsumeTracker_MainFrame, "TOP", 0, 12)
|
|
|
|
|
|
-- Close Button
|
|
local closeButton = CreateFrame("Button", nil, ConsumeTracker_MainFrame, "UIPanelCloseButton")
|
|
closeButton:SetWidth(32)
|
|
closeButton:SetHeight(32)
|
|
closeButton:SetPoint("TOPRIGHT", ConsumeTracker_MainFrame, "TOPRIGHT", -5, -5)
|
|
closeButton:SetScript("OnClick", function()
|
|
ConsumeTracker_MainFrame:Hide()
|
|
end)
|
|
|
|
-- Create a custom tooltip frame
|
|
local tooltipFrame = CreateFrame("Frame", "ConsumeTrackerTooltip", UIParent)
|
|
tooltipFrame:SetWidth(150)
|
|
tooltipFrame:SetHeight(40)
|
|
tooltipFrame:SetFrameStrata("TOOLTIP")
|
|
tooltipFrame:SetBackdrop({
|
|
bgFile = "Interface\\Tooltips\\UI-Tooltip-Background",
|
|
edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
|
|
tile = true, tileSize = 16, edgeSize = 16,
|
|
insets = { left = 4, right = 4, top = 4, bottom = 4 }
|
|
})
|
|
tooltipFrame:SetBackdropColor(0, 0, 0, 1)
|
|
tooltipFrame:Hide()
|
|
|
|
-- Tooltip text
|
|
local tooltipText = tooltipFrame:CreateFontString(nil, "OVERLAY", "GameFontNormal")
|
|
tooltipText:SetPoint("CENTER", tooltipFrame, "CENTER", 0, 0)
|
|
tooltipFrame.text = tooltipText
|
|
|
|
local function ShowTooltip(tab, text)
|
|
tooltipFrame.text:SetText(text)
|
|
tooltipFrame:SetPoint("BOTTOMLEFT", tab, "TOPLEFT", 0, 0)
|
|
tooltipFrame:Show()
|
|
end
|
|
|
|
local function HideTooltip()
|
|
tooltipFrame:Hide()
|
|
end
|
|
|
|
-- Tabs
|
|
local tabs = {}
|
|
local function CreateTab(name, texture, xOffset, tooltipText, tabIndex)
|
|
local tab = CreateFrame("Button", name, ConsumeTracker_MainFrame)
|
|
tab:SetWidth(36)
|
|
tab:SetHeight(36)
|
|
tab:SetPoint("TOPLEFT", ConsumeTracker_MainFrame, "TOPLEFT", xOffset, -30)
|
|
|
|
-- Tab Icon
|
|
local icon = tab:CreateTexture(nil, "ARTWORK")
|
|
icon:SetTexture(texture)
|
|
icon:SetWidth(36)
|
|
icon:SetHeight(36)
|
|
icon:SetPoint("CENTER", tab, "CENTER", 0, 0)
|
|
|
|
tab.icon = icon
|
|
|
|
-- Hover Glow
|
|
local hoverTexture = tab:CreateTexture(nil, "HIGHLIGHT")
|
|
hoverTexture:SetTexture("Interface\\Buttons\\CheckButtonHilight")
|
|
hoverTexture:SetBlendMode("ADD")
|
|
hoverTexture:SetAllPoints(tab)
|
|
|
|
-- Active Highlight
|
|
local activeHighlight = tab:CreateTexture(nil, "OVERLAY")
|
|
activeHighlight:SetTexture("Interface\\Buttons\\CheckButtonHilight")
|
|
activeHighlight:SetBlendMode("ADD")
|
|
activeHighlight:SetAllPoints(tab)
|
|
activeHighlight:SetWidth(36)
|
|
activeHighlight:SetHeight(36)
|
|
activeHighlight:Hide()
|
|
tab.activeHighlight = activeHighlight
|
|
|
|
-- Custom Tooltip Handlers
|
|
tab:SetScript("OnEnter", function()
|
|
ShowTooltip(tab, tooltipText)
|
|
end)
|
|
tab:SetScript("OnLeave", HideTooltip)
|
|
|
|
-- Store tab for later
|
|
tabs[tabIndex] = tab
|
|
|
|
return tab
|
|
end
|
|
|
|
-- Tracker Tab
|
|
local tab1 = CreateTab("ConsumeTracker_MainFrameTab1", "Interface\\Icons\\INV_Potion_93", 30, "Consumables Tracker", 1)
|
|
tab1:SetScript("OnClick", function()
|
|
ConsumeTracker_ShowTab(1)
|
|
end)
|
|
|
|
-- Options Tab
|
|
local tab2 = CreateTab("ConsumeTracker_MainFrameTab2", "Interface\\Icons\\INV_Misc_Gear_01", 80, "Options", 2)
|
|
tab2:SetScript("OnClick", function()
|
|
ConsumeTracker_ShowTab(2)
|
|
end)
|
|
|
|
-- Characters Tab
|
|
local tab3 = CreateTab("ConsumeTracker_MainFrameTab3", "Interface\\Icons\\Ability_Rogue_Disguise", 130, "Characters", 3)
|
|
tab3:SetScript("OnClick", function()
|
|
ConsumeTracker_ShowTab(3)
|
|
end)
|
|
|
|
-- Add Grey Line Under Tabs
|
|
local tabsLine = ConsumeTracker_MainFrame:CreateTexture(nil, "ARTWORK")
|
|
tabsLine:SetHeight(1)
|
|
tabsLine:SetPoint("TOPLEFT", ConsumeTracker_MainFrame, "TOPLEFT", 12, -72)
|
|
tabsLine:SetPoint("TOPRIGHT", ConsumeTracker_MainFrame, "TOPRIGHT", -12, -72)
|
|
tabsLine:SetTexture("Interface\\Buttons\\WHITE8x8")
|
|
tabsLine:SetVertexColor(0.4, 0.4, 0.4, 1)
|
|
|
|
-- Tab Content
|
|
ConsumeTracker_MainFrame.tabs = {}
|
|
local tab1Content = CreateFrame("Frame", nil, ConsumeTracker_MainFrame)
|
|
tab1Content:SetWidth(WindowWidth - 50)
|
|
tab1Content:SetHeight(380)
|
|
tab1Content:SetPoint("TOPLEFT", ConsumeTracker_MainFrame, "TOPLEFT", 30, -80)
|
|
ConsumeTracker_MainFrame.tabs[1] = tab1Content
|
|
|
|
local tab2Content = CreateFrame("Frame", nil, ConsumeTracker_MainFrame)
|
|
tab2Content:SetWidth(WindowWidth - 50)
|
|
tab2Content:SetHeight(380)
|
|
tab2Content:SetPoint("TOPLEFT", ConsumeTracker_MainFrame, "TOPLEFT", 30, -80)
|
|
ConsumeTracker_MainFrame.tabs[2] = tab2Content
|
|
|
|
local tab3Content = CreateFrame("Frame", nil, ConsumeTracker_MainFrame)
|
|
tab3Content:SetWidth(WindowWidth - 50)
|
|
tab3Content:SetHeight(380)
|
|
tab3Content:SetPoint("TOPLEFT", ConsumeTracker_MainFrame, "TOPLEFT", 30, -80)
|
|
ConsumeTracker_MainFrame.tabs[3] = tab3Content
|
|
|
|
-- Footer Text
|
|
local footerText = ConsumeTracker_MainFrame:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
|
|
footerText:SetText("Made by Horyoshi (v" .. Version .. "-" .. VState .. ")")
|
|
footerText:SetTextColor(0.6, 0.6, 0.6)
|
|
footerText:SetPoint("BOTTOM", ConsumeTracker_MainFrame, "BOTTOM", 0, 15)
|
|
|
|
-- Add Grey Line Above Footer
|
|
local footerLine = ConsumeTracker_MainFrame:CreateTexture(nil, "ARTWORK")
|
|
footerLine:SetHeight(1)
|
|
footerLine:SetPoint("BOTTOMLEFT", ConsumeTracker_MainFrame, "BOTTOMLEFT", 12, 30)
|
|
footerLine:SetPoint("BOTTOMRIGHT", ConsumeTracker_MainFrame, "BOTTOMRIGHT", -12, 30)
|
|
footerLine:SetTexture("Interface\\Buttons\\WHITE8x8")
|
|
footerLine:SetVertexColor(0.4, 0.4, 0.4, 1)
|
|
|
|
-- Tab Switching Function
|
|
function ConsumeTracker_ShowTab(tabIndex)
|
|
for index, content in pairs(ConsumeTracker_MainFrame.tabs) do
|
|
if index == tabIndex then
|
|
content:Show()
|
|
tabs[index].activeHighlight:Show()
|
|
else
|
|
content:Hide()
|
|
tabs[index].activeHighlight:Hide()
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Set Default Tab
|
|
ConsumeTracker_ShowTab(1)
|
|
|
|
-- Add Custom Content for Tabs
|
|
ConsumeTracker_CreateTrackerContent(tab1Content)
|
|
ConsumeTracker_CreateOptionsContent(tab2Content)
|
|
ConsumeTracker_CreateCharactersContent(tab3Content)
|
|
end
|
|
|
|
|
|
|
|
-- Function to show the main window
|
|
function ConsumeTracker_ShowMainWindow()
|
|
if not ConsumeTracker_MainFrame then
|
|
ConsumeTracker_CreateMainWindow()
|
|
end
|
|
ConsumeTracker_MainFrame:Show()
|
|
-- Scan inventory when the window is opened
|
|
ConsumeTracker_ScanPlayerInventory()
|
|
-- Only scan bank and mail if they are open
|
|
if BankFrame and BankFrame:IsShown() then
|
|
ConsumeTracker_ScanPlayerBank()
|
|
end
|
|
if MailFrame and MailFrame:IsShown() then
|
|
ConsumeTracker_ScanPlayerMail()
|
|
end
|
|
-- Update the tracker content
|
|
ConsumeTracker_UpdateTrackerContent()
|
|
end
|
|
|
|
-- Function to switch tabs
|
|
function ConsumeTracker_ShowTab(tabIndex)
|
|
if not ConsumeTracker_MainFrame or not ConsumeTracker_MainFrame.tabs then return end
|
|
for i, tabContent in pairs(ConsumeTracker_MainFrame.tabs) do
|
|
if i == tabIndex then
|
|
tabContent:Show()
|
|
-- Set the tab button to active
|
|
local tabButton = getglobal("ConsumeTracker_MainFrameTab" .. i)
|
|
tabButton:SetNormalTexture("Interface\\OptionsFrame\\UI-OptionsFrame-ActiveTab")
|
|
else
|
|
tabContent:Hide()
|
|
-- Set the tab button to inactive
|
|
local tabButton = getglobal("ConsumeTracker_MainFrameTab" .. i)
|
|
tabButton:SetNormalTexture("Interface\\OptionsFrame\\UI-OptionsFrame-InActiveTab")
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Function to create the content of the Tracker tab
|
|
function ConsumeTracker_CreateTrackerContent(parentFrame)
|
|
-- Scroll Frame
|
|
local scrollFrame = CreateFrame("ScrollFrame", "ConsumeTracker_ConsumablesScrollFrame", parentFrame)
|
|
scrollFrame:SetPoint("TOPLEFT", parentFrame, "TOPLEFT", 0, 0)
|
|
scrollFrame:SetPoint("BOTTOMRIGHT", parentFrame, "BOTTOMRIGHT", -20, 0)
|
|
scrollFrame:EnableMouseWheel(true)
|
|
|
|
-- Define the OnMouseWheelHandler method
|
|
function scrollFrame:OnMouseWheelHandler(delta)
|
|
local current = self:GetVerticalScroll()
|
|
local maxScroll = self.range or 0
|
|
local newScroll = math.max(0, math.min(current - (delta * 10), maxScroll))
|
|
self:SetVerticalScroll(newScroll)
|
|
parentFrame.scrollBar:SetValue(newScroll)
|
|
end
|
|
|
|
-- Set the OnMouseWheel script
|
|
scrollFrame:SetScript("OnMouseWheel", function()
|
|
local delta = arg1
|
|
this:OnMouseWheelHandler(delta)
|
|
end)
|
|
|
|
-- Scroll Child Frame
|
|
local scrollChild = CreateFrame("Frame", nil, scrollFrame)
|
|
scrollChild:SetWidth(WindowWidth - 10)
|
|
scrollChild:SetHeight(1) -- Will adjust later
|
|
scrollFrame:SetScrollChild(scrollChild)
|
|
|
|
-- Initialize tables to store category and consumable labels
|
|
parentFrame.categoryLabels = {}
|
|
parentFrame.labels = {}
|
|
|
|
-- Sort categories by name for consistent order
|
|
local sortedCategories = {}
|
|
for categoryName, _ in pairs(consumablesCategories) do
|
|
table.insert(sortedCategories, categoryName)
|
|
end
|
|
table.sort(sortedCategories, function(a, b) return a < b end)
|
|
|
|
local index = 0 -- Initialize index for positioning
|
|
|
|
for _, categoryName in ipairs(sortedCategories) do
|
|
local consumables = consumablesCategories[categoryName]
|
|
|
|
-- Create category label
|
|
local categoryLabel = scrollChild:CreateFontString(nil, "OVERLAY", "GameFontNormalLarge")
|
|
categoryLabel:SetText(categoryName)
|
|
categoryLabel:SetTextColor(1, 1, 1)
|
|
categoryLabel:SetPoint("TOPLEFT", scrollChild, "TOPLEFT", 0, -index * 16)
|
|
categoryLabel:Hide() -- Initially hidden
|
|
parentFrame.categoryLabels[categoryName] = categoryLabel
|
|
index = index + 1 -- Reserve space for category label
|
|
|
|
-- Sort consumables by name
|
|
table.sort(consumables, function(a, b) return a.name < b.name end)
|
|
|
|
for _, consumable in ipairs(consumables) do
|
|
local itemID = consumable.id
|
|
local itemName = consumable.name
|
|
|
|
-- Create consumable label
|
|
local label = scrollChild:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
|
|
label:SetText(itemName)
|
|
label:SetTextColor(1, 1, 1) -- White color
|
|
label:SetPoint("TOPLEFT", scrollChild, "TOPLEFT", 20, -index * 16) -- Indent consumables
|
|
label:Hide() -- Initially hidden
|
|
parentFrame.labels[itemID] = label
|
|
|
|
-- Create a frame for tooltip
|
|
local tooltipFrame = CreateFrame("Frame", nil, scrollChild)
|
|
tooltipFrame:SetWidth(220)
|
|
tooltipFrame:SetHeight(16)
|
|
tooltipFrame:SetPoint("TOPLEFT", scrollChild, "TOPLEFT", 20, -index * 16)
|
|
tooltipFrame:EnableMouse(true)
|
|
tooltipFrame:SetScript("OnEnter", function()
|
|
ConsumeTracker_ShowConsumableTooltip(itemID)
|
|
end)
|
|
tooltipFrame:SetScript("OnLeave", function()
|
|
if ConsumeTracker_CustomTooltip then
|
|
ConsumeTracker_CustomTooltip:Hide()
|
|
end
|
|
end)
|
|
|
|
-- Enable mouse wheel and pass events to the scroll frame
|
|
tooltipFrame:EnableMouseWheel(true)
|
|
tooltipFrame:SetScript("OnMouseWheel", function()
|
|
local delta = arg1
|
|
local scrollFrame = parentFrame.scrollFrame
|
|
if scrollFrame and scrollFrame:IsVisible() then
|
|
scrollFrame:OnMouseWheelHandler(delta)
|
|
end
|
|
end)
|
|
|
|
-- Associate tooltip frame with the label
|
|
label.tooltipFrame = tooltipFrame
|
|
|
|
index = index + 1 -- Increment index for next label
|
|
end
|
|
|
|
-- Add spacing after each category
|
|
index = index + 1
|
|
end
|
|
|
|
-- Adjust the height of the scroll child
|
|
scrollChild.contentHeight = index * 16
|
|
scrollChild:SetHeight(scrollChild.contentHeight)
|
|
|
|
-- Message Label
|
|
local messageLabel = scrollChild:CreateFontString(nil, "OVERLAY", "GameFontNormal")
|
|
messageLabel:SetText("|cffff0000No consumables selected|r\n\n|cffffffffClick on |roptions|cffffffff to get started|r")
|
|
messageLabel:SetPoint("CENTER", ConsumeTracker_MainFrame, "CENTER", 0, 0)
|
|
messageLabel:Hide() -- Initially hidden
|
|
parentFrame.messageLabel = messageLabel
|
|
|
|
-- Scroll Bar
|
|
local scrollBar = CreateFrame("Slider", "ConsumeTracker_TrackerScrollBar", parentFrame)
|
|
scrollBar:SetPoint("TOPRIGHT", parentFrame, "TOPRIGHT", -2, -16)
|
|
scrollBar:SetPoint("BOTTOMRIGHT", parentFrame, "BOTTOMRIGHT", -2, 16)
|
|
scrollBar:SetWidth(16)
|
|
scrollBar:SetOrientation('VERTICAL')
|
|
scrollBar:SetThumbTexture("Interface\\Buttons\\UI-ScrollBar-Knob")
|
|
scrollBar:SetBackdrop({
|
|
bgFile = "Interface\\Buttons\\UI-SliderBar-Background",
|
|
edgeFile = "Interface\\Buttons\\UI-SliderBar-Border",
|
|
tile = true, tileSize = 8, edgeSize = 8,
|
|
insets = { left = 3, right = 3, top = 3, bottom = 3 }
|
|
})
|
|
scrollBar:SetScript("OnValueChanged", function()
|
|
local value = this:GetValue()
|
|
parentFrame.scrollFrame:SetVerticalScroll(value)
|
|
end)
|
|
parentFrame.scrollBar = scrollBar
|
|
parentFrame.scrollFrame = scrollFrame
|
|
parentFrame.scrollChild = scrollChild
|
|
|
|
-- Update the scrollbar
|
|
ConsumeTracker_UpdateTrackerScrollBar()
|
|
end
|
|
|
|
function ConsumeTracker_CreateOptionsContent(parentFrame)
|
|
-- Create Search Input
|
|
local searchBox = CreateFrame("EditBox", "ConsumeTracker_SearchBox", parentFrame, "InputBoxTemplate")
|
|
searchBox:SetWidth(WindowWidth - 50)
|
|
searchBox:SetHeight(20)
|
|
searchBox:SetPoint("TOPLEFT", parentFrame, "TOPLEFT", 0, -5)
|
|
searchBox:SetAutoFocus(false)
|
|
searchBox:SetText("Search...")
|
|
searchBox:SetTextColor(0.5, 0.5, 0.5) -- Placeholder text color
|
|
|
|
searchBox:SetScript("OnEditFocusGained", function()
|
|
if this:GetText() == "Search..." then
|
|
this:SetText("")
|
|
this:SetTextColor(1, 1, 1) -- User input text color
|
|
end
|
|
end)
|
|
|
|
searchBox:SetScript("OnEditFocusLost", function()
|
|
if this:GetText() == "" then
|
|
this:SetText("Search...")
|
|
this:SetTextColor(0.5, 0.5, 0.5) -- Placeholder text color
|
|
end
|
|
end)
|
|
|
|
-- Function to update the filter
|
|
local function UpdateFilter()
|
|
local filterText = string.lower(searchBox:GetText())
|
|
if filterText == "search..." then filterText = "" end
|
|
local index = 0 -- Position index
|
|
local lineHeight = 18
|
|
|
|
-- Iterate over categories
|
|
for _, categoryInfo in ipairs(parentFrame.categoryInfo) do
|
|
local categoryLabel = categoryInfo.label
|
|
local anyOptionVisible = false
|
|
|
|
-- First, check if any options in the category match the filter
|
|
for _, optionInfo in ipairs(categoryInfo.options) do
|
|
local itemNameLower = string.lower(optionInfo.name)
|
|
|
|
if filterText == "" or string.find(itemNameLower, filterText, 1, true) then
|
|
anyOptionVisible = true
|
|
break
|
|
end
|
|
end
|
|
|
|
-- If any options are visible, show the category label
|
|
if anyOptionVisible then
|
|
categoryLabel:SetPoint("TOPLEFT", parentFrame.scrollChild, "TOPLEFT", 0, - (index) * lineHeight)
|
|
categoryLabel:Show()
|
|
index = index + 1
|
|
|
|
-- Now, position and show the matching options
|
|
for _, optionInfo in ipairs(categoryInfo.options) do
|
|
local optionFrame = optionInfo.frame
|
|
local itemNameLower = string.lower(optionInfo.name)
|
|
|
|
if filterText == "" or string.find(itemNameLower, filterText, 1, true) then
|
|
-- Show the option
|
|
optionFrame:SetPoint("TOPLEFT", parentFrame.scrollChild, "TOPLEFT", 0, - (index) * lineHeight)
|
|
optionFrame:Show()
|
|
index = index + 1
|
|
else
|
|
optionFrame:Hide()
|
|
end
|
|
end
|
|
|
|
-- Add extra spacing after the category
|
|
index = index + 1 -- Add one extra line of spacing between categories
|
|
|
|
else
|
|
categoryLabel:Hide()
|
|
-- Hide all options under this category
|
|
for _, optionInfo in ipairs(categoryInfo.options) do
|
|
optionInfo.frame:Hide()
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Adjust the scroll child height
|
|
parentFrame.scrollChild.contentHeight = index * lineHeight
|
|
parentFrame.scrollChild:SetHeight(parentFrame.scrollChild.contentHeight)
|
|
|
|
-- Update the scrollbar
|
|
ConsumeTracker_UpdateOptionsScrollBar()
|
|
end
|
|
|
|
searchBox:SetScript("OnTextChanged", function()
|
|
UpdateFilter()
|
|
end)
|
|
|
|
-- Adjust the size of the scroll frame to make room for the search box and add extra spacing
|
|
local scrollFrame = CreateFrame("ScrollFrame", "ConsumeTracker_OptionsScrollFrame", parentFrame)
|
|
scrollFrame:SetPoint("TOPLEFT", parentFrame, "TOPLEFT", 0, -40) -- Changed from -30 to -50 for extra spacing
|
|
scrollFrame:SetPoint("BOTTOMRIGHT", parentFrame, "BOTTOMRIGHT", -20, 0)
|
|
scrollFrame:EnableMouseWheel(true)
|
|
scrollFrame:SetScript("OnMouseWheel", function()
|
|
local delta = arg1
|
|
local current = this:GetVerticalScroll()
|
|
local maxScroll = this.maxScroll or 0
|
|
local newScroll = math.max(0, math.min(current - (delta * 20), maxScroll))
|
|
this:SetVerticalScroll(newScroll)
|
|
parentFrame.scrollBar:SetValue(newScroll)
|
|
end)
|
|
|
|
-- Scroll Child Frame
|
|
local scrollChild = CreateFrame("Frame", nil, scrollFrame)
|
|
scrollChild:SetWidth(WindowWidth - 10)
|
|
scrollChild:SetHeight(1) -- Will adjust later
|
|
scrollFrame:SetScrollChild(scrollChild)
|
|
parentFrame.scrollChild = scrollChild
|
|
parentFrame.scrollFrame = scrollFrame
|
|
|
|
-- Sort categories alphabetically
|
|
local sortedCategories = {}
|
|
for categoryName, _ in pairs(consumablesCategories) do
|
|
table.insert(sortedCategories, categoryName)
|
|
end
|
|
table.sort(sortedCategories)
|
|
|
|
-- Checkboxes
|
|
parentFrame.checkboxes = {}
|
|
parentFrame.categoryInfo = {}
|
|
local index = 0 -- Position index
|
|
local lineHeight = 18
|
|
|
|
-- Iterate over sorted categories
|
|
for _, categoryName in ipairs(sortedCategories) do
|
|
local consumables = consumablesCategories[categoryName]
|
|
|
|
-- Create category label
|
|
local categoryLabel = scrollChild:CreateFontString(nil, "OVERLAY", "GameFontNormalLarge")
|
|
categoryLabel:SetText(categoryName)
|
|
categoryLabel:SetTextColor(1, 1, 1)
|
|
categoryLabel:Show()
|
|
|
|
local categoryInfo = { name = categoryName, label = categoryLabel, options = {} }
|
|
|
|
index = index + 1 -- Position for the category label
|
|
|
|
local numOptionsInCategory = 0 -- Counter for options in this category
|
|
|
|
-- Sort the consumables by name
|
|
table.sort(consumables, function(a, b) return a.name < b.name end)
|
|
|
|
-- For each consumable in the category
|
|
for _, consumable in ipairs(consumables) do
|
|
local currentItemID = consumable.id
|
|
local itemName = consumable.name
|
|
|
|
-- Create a frame that encompasses the checkbox and label
|
|
local optionFrame = CreateFrame("Frame", "ConsumeTracker_OptionsFrame" .. index, scrollChild)
|
|
optionFrame:SetWidth(WindowWidth - 10)
|
|
optionFrame:SetHeight(lineHeight)
|
|
optionFrame:SetPoint("TOPLEFT", scrollChild, "TOPLEFT", 0, - (index) * lineHeight)
|
|
optionFrame:Show()
|
|
|
|
-- Create the checkbox inside the optionFrame
|
|
local checkbox = CreateFrame("CheckButton", "ConsumeTracker_OptionsCheckbox" .. index, optionFrame)
|
|
checkbox:SetWidth(16)
|
|
checkbox:SetHeight(16)
|
|
checkbox:SetPoint("LEFT", optionFrame, "LEFT", 0, 0)
|
|
|
|
-- Create Textures for the checkbox
|
|
checkbox:SetNormalTexture("Interface\\Buttons\\UI-CheckBox-Up")
|
|
checkbox:SetPushedTexture("Interface\\Buttons\\UI-CheckBox-Down")
|
|
checkbox:SetHighlightTexture("Interface\\Buttons\\UI-CheckBox-Highlight")
|
|
checkbox:SetCheckedTexture("Interface\\Buttons\\UI-CheckBox-Check")
|
|
|
|
-- Create FontString for label
|
|
local label = optionFrame:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
|
|
label:SetPoint("LEFT", checkbox, "RIGHT", 4, 0)
|
|
label:SetText(itemName)
|
|
|
|
-- Set up the checkbox OnClick handler
|
|
checkbox:SetScript("OnClick", function()
|
|
ConsumeTracker_Settings[currentItemID] = checkbox:GetChecked()
|
|
ConsumeTracker_UpdateTrackerContent()
|
|
end)
|
|
-- Load saved setting
|
|
if ConsumeTracker_Settings[currentItemID] then
|
|
checkbox:SetChecked(true)
|
|
end
|
|
parentFrame.checkboxes[currentItemID] = checkbox
|
|
|
|
-- Make the optionFrame clickable
|
|
optionFrame:EnableMouse(true)
|
|
optionFrame:SetScript("OnMouseDown", function()
|
|
checkbox:Click()
|
|
end)
|
|
|
|
-- Mouseover Tooltip
|
|
optionFrame:SetScript("OnEnter", function()
|
|
ConsumeTracker_ShowOptionsTooltip(currentItemID)
|
|
end)
|
|
optionFrame:SetScript("OnLeave", function()
|
|
if ConsumeTracker_OptionsTooltip then
|
|
ConsumeTracker_OptionsTooltip:Hide()
|
|
end
|
|
end)
|
|
|
|
-- Store option info
|
|
table.insert(categoryInfo.options, { frame = optionFrame, name = itemName })
|
|
|
|
index = index + 1 -- Increment index after adding option
|
|
numOptionsInCategory = numOptionsInCategory + 1 -- Increment options count
|
|
end
|
|
|
|
-- Position the category label above its options
|
|
categoryLabel:SetPoint("TOPLEFT", scrollChild, "TOPLEFT", 0, - (index - numOptionsInCategory - 1) * lineHeight)
|
|
|
|
-- Store category info
|
|
table.insert(parentFrame.categoryInfo, categoryInfo)
|
|
|
|
-- Add extra spacing after the category
|
|
index = index + 1 -- Add one extra line of spacing between categories
|
|
end
|
|
|
|
-- Adjust the scroll child height
|
|
scrollChild.contentHeight = (index - 1) * lineHeight
|
|
scrollChild:SetHeight(scrollChild.contentHeight)
|
|
|
|
-- Scroll Bar
|
|
local scrollBar = CreateFrame("Slider", "ConsumeTracker_OptionsScrollBar", parentFrame)
|
|
scrollBar:SetPoint("TOPRIGHT", parentFrame, "TOPRIGHT", -2, -56) -- Adjusted for extra spacing
|
|
scrollBar:SetPoint("BOTTOMRIGHT", parentFrame, "BOTTOMRIGHT", -2, 16)
|
|
scrollBar:SetWidth(16)
|
|
scrollBar:SetOrientation('VERTICAL')
|
|
scrollBar:SetThumbTexture("Interface\\Buttons\\UI-ScrollBar-Knob")
|
|
scrollBar:SetBackdrop({
|
|
bgFile = "Interface\\Buttons\\UI-SliderBar-Background",
|
|
edgeFile = "Interface\\Buttons\\UI-SliderBar-Border",
|
|
tile = true, tileSize = 8, edgeSize = 8,
|
|
insets = { left = 3, right = 3, top = 3, bottom = 3 }
|
|
})
|
|
scrollBar:SetScript("OnValueChanged", function()
|
|
local value = this:GetValue()
|
|
parentFrame.scrollFrame:SetVerticalScroll(value)
|
|
end)
|
|
parentFrame.scrollBar = scrollBar
|
|
|
|
-- Update the scrollbar
|
|
ConsumeTracker_UpdateOptionsScrollBar()
|
|
end
|
|
|
|
|
|
function ConsumeTracker_CreateCharactersContent(parentFrame)
|
|
-- Scroll Frame
|
|
local scrollFrame = CreateFrame("ScrollFrame", "ConsumeTracker_CharactersScrollFrame", parentFrame)
|
|
scrollFrame:SetPoint("TOPLEFT", parentFrame, "TOPLEFT", 0, 0)
|
|
scrollFrame:SetPoint("BOTTOMRIGHT", parentFrame, "BOTTOMRIGHT", -20, 0)
|
|
scrollFrame:EnableMouseWheel(true)
|
|
scrollFrame:SetScript("OnMouseWheel", function()
|
|
local delta = arg1
|
|
local current = scrollFrame:GetVerticalScroll()
|
|
local maxScroll = scrollFrame.maxScroll or 0
|
|
local newScroll = math.max(0, math.min(current - (delta * 20), maxScroll))
|
|
scrollFrame:SetVerticalScroll(newScroll)
|
|
if parentFrame.scrollBar then
|
|
parentFrame.scrollBar:SetValue(newScroll)
|
|
end
|
|
end)
|
|
|
|
-- Scroll Child Frame
|
|
local scrollChild = CreateFrame("Frame", nil, scrollFrame)
|
|
scrollChild:SetWidth(WindowWidth - 10)
|
|
scrollChild:SetHeight(1)
|
|
scrollFrame:SetScrollChild(scrollChild)
|
|
|
|
-- Initialize variables
|
|
parentFrame.checkboxes = {}
|
|
local index = 0 -- Position index
|
|
|
|
-- Ensure settings table for characters exists
|
|
ConsumeTracker_Settings["Characters"] = ConsumeTracker_Settings["Characters"] or {}
|
|
|
|
-- Get list of characters
|
|
local realmName = GetRealmName()
|
|
local faction = UnitFactionGroup("player")
|
|
local playerName = UnitName("player")
|
|
|
|
local characterList = {}
|
|
|
|
-- Ensure data structure exists
|
|
if ConsumeTracker_Data[realmName] and ConsumeTracker_Data[realmName][faction] then
|
|
for characterName, _ in pairs(ConsumeTracker_Data[realmName][faction]) do
|
|
table.insert(characterList, characterName)
|
|
end
|
|
end
|
|
|
|
-- Ensure current character is included
|
|
local playerInList = false
|
|
for _, name in ipairs(characterList) do
|
|
if name == playerName then
|
|
playerInList = true
|
|
break
|
|
end
|
|
end
|
|
if not playerInList then
|
|
table.insert(characterList, playerName)
|
|
end
|
|
|
|
-- Sort the character list
|
|
table.sort(characterList)
|
|
|
|
-- Create FontString for title
|
|
local title = scrollChild:CreateFontString(nil, "OVERLAY", "GameFontNormal")
|
|
title:SetPoint("TOPLEFT", scrollChild, "TOPLEFT", 0, 0) -- Offset from the top
|
|
title:SetText("Select Characters to Track")
|
|
title:SetTextColor(1, 1, 1)
|
|
|
|
-- Offset index to start below the title
|
|
local startYOffset = 20
|
|
|
|
-- For each character
|
|
for _, characterName in ipairs(characterList) do
|
|
index = index + 1
|
|
|
|
-- Create a local copy of characterName for the closure
|
|
local currentCharacterName = characterName
|
|
|
|
-- Create a frame that encompasses the checkbox and label
|
|
local optionFrame = CreateFrame("Frame", "ConsumeTracker_CharacterFrame" .. index, scrollChild)
|
|
optionFrame:SetWidth(WindowWidth - 10)
|
|
optionFrame:SetHeight(18)
|
|
optionFrame:SetPoint("TOPLEFT", scrollChild, "TOPLEFT", 0, -(startYOffset + (index - 1) * 20))
|
|
|
|
-- Create the checkbox inside the optionFrame
|
|
local checkbox = CreateFrame("CheckButton", "ConsumeTracker_CharacterCheckbox" .. index, optionFrame)
|
|
checkbox:SetWidth(16)
|
|
checkbox:SetHeight(16)
|
|
checkbox:SetPoint("LEFT", optionFrame, "LEFT", 0, 0)
|
|
|
|
-- Create Textures for the checkbox
|
|
checkbox:SetNormalTexture("Interface\\Buttons\\UI-CheckBox-Up")
|
|
checkbox:SetPushedTexture("Interface\\Buttons\\UI-CheckBox-Down")
|
|
checkbox:SetHighlightTexture("Interface\\Buttons\\UI-CheckBox-Highlight")
|
|
checkbox:SetCheckedTexture("Interface\\Buttons\\UI-CheckBox-Check")
|
|
|
|
-- Create FontString for label
|
|
local label = optionFrame:CreateFontString(nil, "OVERLAY", "GameFontNormal")
|
|
label:SetPoint("LEFT", checkbox, "RIGHT", 4, 0)
|
|
label:SetText(currentCharacterName)
|
|
|
|
-- Set up the checkbox OnClick handler
|
|
checkbox:SetScript("OnClick", function()
|
|
if checkbox:GetChecked() then
|
|
ConsumeTracker_Settings["Characters"][currentCharacterName] = true
|
|
else
|
|
ConsumeTracker_Settings["Characters"][currentCharacterName] = false
|
|
end
|
|
ConsumeTracker_UpdateTrackerContent()
|
|
end)
|
|
-- Load saved setting
|
|
if ConsumeTracker_Settings["Characters"][currentCharacterName] == nil then
|
|
-- Default to checked
|
|
checkbox:SetChecked(true)
|
|
ConsumeTracker_Settings["Characters"][currentCharacterName] = true
|
|
else
|
|
checkbox:SetChecked(ConsumeTracker_Settings["Characters"][currentCharacterName])
|
|
end
|
|
parentFrame.checkboxes[currentCharacterName] = checkbox
|
|
|
|
-- Make the optionFrame clickable (so clicking on the label checks/unchecks the box)
|
|
optionFrame:EnableMouse(true)
|
|
optionFrame:SetScript("OnMouseDown", function()
|
|
checkbox:Click()
|
|
end)
|
|
end
|
|
|
|
-- Adjust the scroll child height
|
|
scrollChild.contentHeight = startYOffset + index * 20
|
|
scrollChild:SetHeight(scrollChild.contentHeight)
|
|
|
|
-- Scroll Bar
|
|
local scrollBar = CreateFrame("Slider", "ConsumeTracker_CharactersScrollBar", parentFrame)
|
|
scrollBar:SetPoint("TOPRIGHT", parentFrame, "TOPRIGHT", -2, -16)
|
|
scrollBar:SetPoint("BOTTOMRIGHT", parentFrame, "BOTTOMRIGHT", -2, 16)
|
|
scrollBar:SetWidth(16)
|
|
scrollBar:SetOrientation('VERTICAL')
|
|
scrollBar:SetThumbTexture("Interface\\Buttons\\UI-ScrollBar-Knob")
|
|
scrollBar:SetBackdrop({
|
|
bgFile = "Interface\\Buttons\\UI-SliderBar-Background",
|
|
edgeFile = "Interface\\Buttons\\UI-SliderBar-Border",
|
|
tile = true, tileSize = 8, edgeSize = 8,
|
|
insets = { left = 3, right = 3, top = 3, bottom = 3 }
|
|
})
|
|
scrollBar:SetScript("OnValueChanged", function()
|
|
local value = scrollBar:GetValue()
|
|
scrollFrame:SetVerticalScroll(value)
|
|
end)
|
|
parentFrame.scrollBar = scrollBar
|
|
parentFrame.scrollFrame = scrollFrame
|
|
parentFrame.scrollChild = scrollChild
|
|
|
|
-- Update the scrollbar
|
|
ConsumeTracker_UpdateCharactersScrollBar()
|
|
end
|
|
|
|
|
|
function ConsumeTracker_UpdateTrackerContent()
|
|
if not ConsumeTracker_MainFrame or not ConsumeTracker_MainFrame.tabs or not ConsumeTracker_MainFrame.tabs[1] then
|
|
return
|
|
end
|
|
|
|
local trackerFrame = ConsumeTracker_MainFrame.tabs[1]
|
|
local realmName = GetRealmName()
|
|
local faction = UnitFactionGroup("player")
|
|
local playerName = UnitName("player")
|
|
|
|
-- Ensure data structure exists
|
|
if not ConsumeTracker_Data[realmName] or not ConsumeTracker_Data[realmName][faction] then
|
|
return
|
|
end
|
|
local data = ConsumeTracker_Data[realmName][faction]
|
|
|
|
-- Check if bank and mail have been scanned for current character
|
|
local currentCharData = data[playerName]
|
|
local bankScanned = currentCharData and currentCharData["bank"] ~= nil
|
|
local mailScanned = currentCharData and currentCharData["mail"] ~= nil
|
|
|
|
-- If bank and mail have not been scanned, show message and hide item labels
|
|
if not bankScanned or not mailScanned then
|
|
-- Hide all labels
|
|
for _, label in pairs(trackerFrame.labels) do
|
|
label:Hide()
|
|
if label.tooltipFrame then
|
|
label.tooltipFrame:Hide()
|
|
end
|
|
end
|
|
-- Hide category labels
|
|
for _, categoryLabel in pairs(trackerFrame.categoryLabels) do
|
|
categoryLabel:Hide()
|
|
end
|
|
|
|
-- Show message
|
|
trackerFrame.messageLabel:SetText("|cffff0000This character is not scanned yet|r\n\n|cffffffffOpen your |rBank|cffffffff and |rMail |cffffffffto get started|r")
|
|
trackerFrame.messageLabel:Show()
|
|
|
|
-- Adjust scroll child height
|
|
trackerFrame.scrollChild:SetHeight(50)
|
|
|
|
-- Update the tracker scrollbar
|
|
ConsumeTracker_UpdateTrackerScrollBar()
|
|
|
|
return
|
|
end
|
|
|
|
-- Proceed with normal content update
|
|
local index = 0 -- Positioning index for items
|
|
local totalCounts = {} -- Track total counts for each item
|
|
local hasAnyVisibleItems = false -- Track if any items are visible
|
|
|
|
-- Sort categories alphabetically for consistent order
|
|
local sortedCategories = {}
|
|
for categoryName, _ in pairs(consumablesCategories) do
|
|
table.insert(sortedCategories, categoryName)
|
|
end
|
|
table.sort(sortedCategories)
|
|
|
|
-- Hide all labels initially to ensure proper cleanup
|
|
for _, label in pairs(trackerFrame.labels) do
|
|
label:Hide()
|
|
if label.tooltipFrame then
|
|
label.tooltipFrame:Hide()
|
|
end
|
|
end
|
|
|
|
-- Hide all category labels initially
|
|
for _, categoryLabel in pairs(trackerFrame.categoryLabels) do
|
|
categoryLabel:Hide()
|
|
end
|
|
|
|
-- Ensure character settings exist
|
|
ConsumeTracker_Settings["Characters"] = ConsumeTracker_Settings["Characters"] or {}
|
|
|
|
-- Iterate over categories
|
|
for _, categoryName in ipairs(sortedCategories) do
|
|
local consumables = consumablesCategories[categoryName]
|
|
local hasVisibleItems = false
|
|
local categoryLabel = trackerFrame.categoryLabels[categoryName]
|
|
|
|
-- Ensure the category label exists
|
|
if not categoryLabel then
|
|
-- Create category label dynamically if missing
|
|
categoryLabel = trackerFrame.scrollChild:CreateFontString(nil, "OVERLAY", "GameFontNormalLarge")
|
|
categoryLabel:SetText(categoryName)
|
|
categoryLabel:SetTextColor(1, 1, 1)
|
|
trackerFrame.categoryLabels[categoryName] = categoryLabel
|
|
end
|
|
|
|
-- Position category label (always above items)
|
|
categoryLabel:SetPoint("TOPLEFT", trackerFrame.scrollChild, "TOPLEFT", 0, -index * 16)
|
|
categoryLabel:Hide() -- Initially hidden
|
|
|
|
index = index + 1 -- Reserve space for the category label
|
|
|
|
-- Calculate totals and show items if enabled
|
|
for _, consumable in ipairs(consumables) do
|
|
local itemID = consumable.id
|
|
if ConsumeTracker_Settings[itemID] then
|
|
hasVisibleItems = true
|
|
hasAnyVisibleItems = true -- Set to true when an item is displayed
|
|
totalCounts[itemID] = 0 -- Initialize count
|
|
|
|
-- Sum counts across all selected characters
|
|
for character, charData in pairs(data) do
|
|
if ConsumeTracker_Settings["Characters"][character] == true then
|
|
-- Proceed with counting
|
|
local inventory = charData["inventory"] and charData["inventory"][itemID] or 0
|
|
local bank = charData["bank"] and charData["bank"][itemID] or 0
|
|
local mail = charData["mail"] and charData["mail"][itemID] or 0
|
|
totalCounts[itemID] = totalCounts[itemID] + inventory + bank + mail
|
|
end
|
|
end
|
|
|
|
-- Show and position item label
|
|
local label = trackerFrame.labels[itemID]
|
|
if not label then
|
|
-- Create the label dynamically if missing
|
|
label = trackerFrame.scrollChild:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
|
|
trackerFrame.labels[itemID] = label
|
|
-- Tooltip frame
|
|
local tooltipFrame = CreateFrame("Frame", nil, trackerFrame.scrollChild)
|
|
tooltipFrame:SetWidth(WindowWidth - 30)
|
|
tooltipFrame:SetHeight(16)
|
|
tooltipFrame:EnableMouse(true)
|
|
tooltipFrame:SetScript("OnEnter", function() ConsumeTracker_ShowConsumableTooltip(itemID) end)
|
|
tooltipFrame:SetScript("OnLeave", function()
|
|
if ConsumeTracker_CustomTooltip then
|
|
ConsumeTracker_CustomTooltip:Hide()
|
|
end
|
|
end)
|
|
label.tooltipFrame = tooltipFrame
|
|
end
|
|
|
|
local totalCount = totalCounts[itemID]
|
|
label:SetText(consumable.name .. " (" .. totalCount .. ")")
|
|
label:SetPoint("TOPLEFT", trackerFrame.scrollChild, "TOPLEFT", 20, -index * 16)
|
|
label:Show()
|
|
|
|
-- Adjust label color based on count
|
|
if totalCount == 0 then
|
|
label:SetTextColor(1, 0, 0) -- Red
|
|
elseif totalCount < 10 then
|
|
label:SetTextColor(1, 0.4, 0) -- Orange
|
|
elseif totalCount <= 20 then
|
|
label:SetTextColor(1, 0.85, 0) -- Yellow
|
|
else
|
|
label:SetTextColor(0, 1, 0) -- Green
|
|
end
|
|
|
|
-- Show tooltip frame
|
|
if label.tooltipFrame then
|
|
label.tooltipFrame:SetPoint("TOPLEFT", trackerFrame.scrollChild, "TOPLEFT", 20, -index * 16)
|
|
label.tooltipFrame:SetWidth(label:GetStringWidth())
|
|
label.tooltipFrame:SetHeight(16)
|
|
label.tooltipFrame:Show()
|
|
end
|
|
|
|
index = index + 1
|
|
end
|
|
end
|
|
|
|
-- Show the category label if it has visible items
|
|
if hasVisibleItems then
|
|
categoryLabel:Show()
|
|
else
|
|
index = index - 1 -- Remove extra space if no items
|
|
end
|
|
end
|
|
|
|
-- Adjust scroll child height based on the total number of items
|
|
local contentHeight = index * 16
|
|
if contentHeight < 50 then
|
|
contentHeight = 50 -- Minimum height to display the message label
|
|
end
|
|
trackerFrame.scrollChild:SetHeight(contentHeight)
|
|
|
|
if not hasAnyVisibleItems then
|
|
-- Show message when no items are selected
|
|
trackerFrame.messageLabel:SetText("|cffff0000No consumables selected|r\n\n|cffffffffClick on |roptions|cffffffff to get started|r")
|
|
trackerFrame.messageLabel:Show()
|
|
else
|
|
-- Hide the message label as we have content to display
|
|
trackerFrame.messageLabel:Hide()
|
|
end
|
|
|
|
-- Update the tracker scrollbar
|
|
ConsumeTracker_UpdateTrackerScrollBar()
|
|
end
|
|
|
|
|
|
|
|
function ConsumeTracker_UpdateTrackerScrollBar()
|
|
local trackerFrame = ConsumeTracker_MainFrame.tabs[1]
|
|
local scrollBar = trackerFrame.scrollBar
|
|
local scrollFrame = trackerFrame.scrollFrame
|
|
local scrollChild = trackerFrame.scrollChild
|
|
|
|
local totalHeight = scrollChild:GetHeight()
|
|
local shownHeight = trackerFrame:GetHeight() - 20 -- Account for padding/margins
|
|
|
|
if totalHeight > shownHeight then
|
|
local maxScroll = totalHeight - shownHeight
|
|
scrollFrame.range = maxScroll -- Set the scroll range
|
|
scrollBar:SetMinMaxValues(0, maxScroll)
|
|
scrollBar:SetValue(math.min(scrollBar:GetValue(), maxScroll))
|
|
scrollBar:Show()
|
|
else
|
|
scrollFrame.range = 0 -- Also handle this case
|
|
scrollBar:SetMinMaxValues(0, 0)
|
|
scrollBar:SetValue(0)
|
|
scrollBar:Hide()
|
|
end
|
|
end
|
|
|
|
|
|
|
|
function ConsumeTracker_UpdateOptionsScrollBar()
|
|
local optionsFrame = ConsumeTracker_MainFrame.tabs[2]
|
|
local scrollBar = optionsFrame.scrollBar
|
|
local scrollFrame = optionsFrame.scrollFrame
|
|
local scrollChild = optionsFrame.scrollChild
|
|
|
|
local totalHeight = scrollChild.contentHeight
|
|
local parentHeight = optionsFrame:GetHeight()
|
|
local searchBoxHeight = 36 -- Adjusted height including padding
|
|
local shownHeight = parentHeight - searchBoxHeight - 20
|
|
|
|
local maxScroll = math.max(0, totalHeight - shownHeight)
|
|
scrollFrame.maxScroll = maxScroll
|
|
|
|
if totalHeight > shownHeight then
|
|
scrollBar:SetMinMaxValues(0, maxScroll)
|
|
scrollBar:SetValue(math.min(scrollBar:GetValue(), maxScroll))
|
|
scrollBar:Show()
|
|
else
|
|
scrollBar:SetMinMaxValues(0, 0)
|
|
scrollBar:SetValue(0)
|
|
scrollBar:Hide()
|
|
end
|
|
end
|
|
|
|
function ConsumeTracker_UpdateCharactersScrollBar()
|
|
local charactersFrame = ConsumeTracker_MainFrame.tabs[3]
|
|
local scrollBar = charactersFrame.scrollBar
|
|
local scrollFrame = charactersFrame.scrollFrame
|
|
local scrollChild = charactersFrame.scrollChild
|
|
|
|
local totalHeight = scrollChild.contentHeight
|
|
local shownHeight = 320 -- Adjust based on your UI
|
|
|
|
local maxScroll = math.max(0, totalHeight - shownHeight)
|
|
scrollFrame.maxScroll = maxScroll
|
|
|
|
if totalHeight > shownHeight then
|
|
scrollBar:SetMinMaxValues(0, maxScroll)
|
|
scrollBar:SetValue(math.min(scrollBar:GetValue(), maxScroll))
|
|
scrollBar:Show()
|
|
else
|
|
scrollBar:SetMinMaxValues(0, 0)
|
|
scrollBar:SetValue(0)
|
|
scrollBar:Hide()
|
|
end
|
|
end
|
|
|
|
|
|
function ConsumeTracker_ShowConsumableTooltip(itemID)
|
|
-- Ensure item is enabled in settings
|
|
if not ConsumeTracker_Settings[itemID] then
|
|
return
|
|
end
|
|
|
|
-- Create or reuse custom tooltip frame
|
|
if not ConsumeTracker_CustomTooltip then
|
|
-- Create the frame
|
|
local tooltipFrame = CreateFrame("Frame", "ConsumeTracker_CustomTooltip", UIParent)
|
|
tooltipFrame:SetFrameStrata("TOOLTIP")
|
|
tooltipFrame:SetWidth(200)
|
|
tooltipFrame:SetBackdrop({
|
|
bgFile = "Interface\\Tooltips\\UI-Tooltip-Background",
|
|
edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
|
|
tile = true, tileSize = 16, edgeSize = 16,
|
|
insets = { left = 4, right = 4, top = 4, bottom = 4 }
|
|
})
|
|
tooltipFrame:SetBackdropColor(0, 0, 0, 1)
|
|
|
|
-- Item icon
|
|
local icon = tooltipFrame:CreateTexture(nil, "ARTWORK")
|
|
icon:SetWidth(32)
|
|
icon:SetHeight(32)
|
|
icon:SetPoint("TOPLEFT", tooltipFrame, "TOPLEFT", 10, -10)
|
|
tooltipFrame.icon = icon
|
|
|
|
-- Item name
|
|
local title = tooltipFrame:CreateFontString(nil, "OVERLAY", "GameFontNormal")
|
|
title:SetPoint("TOPLEFT", icon, "TOPRIGHT", 10, -2)
|
|
title:SetPoint("RIGHT", tooltipFrame, "RIGHT", -10, 0)
|
|
title:SetJustifyH("LEFT")
|
|
title:SetTextColor(1,1,1)
|
|
tooltipFrame.title = title
|
|
|
|
-- Item Total
|
|
local total = tooltipFrame:CreateFontString(nil, "OVERLAY", "GameFontNormalLarge")
|
|
total:SetPoint("TOPLEFT", icon, "TOPRIGHT", 10, -20)
|
|
total:SetPoint("RIGHT", tooltipFrame, "RIGHT", -10, 0)
|
|
total:SetJustifyH("LEFT")
|
|
tooltipFrame.total = total
|
|
|
|
-- Content text
|
|
local content = tooltipFrame:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
|
|
content:SetPoint("TOPLEFT", icon, "BOTTOMLEFT", 0, -10)
|
|
content:SetPoint("RIGHT", tooltipFrame, "RIGHT", -10, 0)
|
|
content:SetJustifyH("LEFT")
|
|
tooltipFrame.content = content
|
|
|
|
ConsumeTracker_CustomTooltip = tooltipFrame
|
|
end
|
|
|
|
local tooltipFrame = ConsumeTracker_CustomTooltip
|
|
|
|
-- Get item info
|
|
local itemName = consumablesList[itemID] or "Unknown Item"
|
|
local itemTexture = consumablesTexture[itemID] or "Interface\\Icons\\INV_Misc_QuestionMark"
|
|
|
|
-- Set icon and title
|
|
tooltipFrame.icon:SetTexture(itemTexture)
|
|
tooltipFrame.title:SetText(itemName)
|
|
|
|
-- Prepare content text
|
|
local contentText = ""
|
|
|
|
local realmName = GetRealmName()
|
|
local faction = UnitFactionGroup("player")
|
|
local playerName = UnitName("player")
|
|
|
|
-- Ensure data structure exists
|
|
ConsumeTracker_Data[realmName] = ConsumeTracker_Data[realmName] or {}
|
|
ConsumeTracker_Data[realmName][faction] = ConsumeTracker_Data[realmName][faction] or {}
|
|
|
|
local data = ConsumeTracker_Data[realmName][faction]
|
|
|
|
-- Initialize totals
|
|
local totalInventory, totalBank, totalMail = 0, 0, 0
|
|
local hasItems = false
|
|
local characterList = {}
|
|
|
|
-- Ensure character settings exist
|
|
ConsumeTracker_Settings["Characters"] = ConsumeTracker_Settings["Characters"] or {}
|
|
|
|
-- Collect data for each character
|
|
for character, charData in pairs(data) do
|
|
if ConsumeTracker_Settings["Characters"][character] == true then
|
|
local inventory = charData["inventory"] and charData["inventory"][itemID] or 0
|
|
local bank = charData["bank"] and charData["bank"][itemID] or 0
|
|
local mail = charData["mail"] and charData["mail"][itemID] or 0
|
|
local total = inventory + bank + mail
|
|
|
|
if total > 0 then
|
|
hasItems = true
|
|
totalInventory = totalInventory + inventory
|
|
totalBank = totalBank + bank
|
|
totalMail = totalMail + mail
|
|
|
|
table.insert(characterList, {
|
|
name = character,
|
|
inventory = inventory,
|
|
bank = bank,
|
|
mail = mail,
|
|
total = total,
|
|
isPlayer = (character == playerName)
|
|
})
|
|
end
|
|
end
|
|
end
|
|
|
|
local totalItems = totalInventory + totalBank + totalMail
|
|
-- Adjust label color based on count
|
|
if totalItems == 0 then
|
|
tooltipFrame.total:SetTextColor(1, 0, 0) -- Red
|
|
elseif totalItems < 10 then
|
|
tooltipFrame.total:SetTextColor(1, 0.4, 0) -- Orange
|
|
elseif totalItems <= 20 then
|
|
tooltipFrame.total:SetTextColor(1, 0.85, 0) -- Yellow
|
|
else
|
|
tooltipFrame.total:SetTextColor(0, 1, 0) -- Green
|
|
end
|
|
|
|
tooltipFrame.total:SetText("Total: " .. totalItems)
|
|
|
|
if not hasItems then
|
|
contentText = contentText .. "|cffff0000No items found for this consumable.|r"
|
|
else
|
|
|
|
-- Sort characters alphabetically (optional)
|
|
table.sort(characterList, function(a, b) return a.name < b.name end)
|
|
|
|
-- Display data for each character
|
|
for _, charInfo in ipairs(characterList) do
|
|
|
|
local nameColor = charInfo.isPlayer and "|cff00ff00" or "|cffffffff" -- Green for player, grey for others
|
|
contentText = contentText .. nameColor .. charInfo.name .. " (" .. charInfo.total .. ")|r\n"
|
|
|
|
local detailText = ""
|
|
if charInfo.inventory > 0 then
|
|
detailText = detailText .. "|cffffffffInventory:|r " .. charInfo.inventory .. " "
|
|
end
|
|
if charInfo.bank > 0 then
|
|
detailText = detailText .. "|cffffffffBank:|r " .. charInfo.bank .. " "
|
|
end
|
|
if charInfo.mail > 0 then
|
|
detailText = detailText .. "|cffffffffMail:|r " .. charInfo.mail .. " "
|
|
end
|
|
|
|
contentText = contentText .. " " .. detailText .. "\n\n"
|
|
end
|
|
end
|
|
|
|
tooltipFrame.content:SetText(contentText)
|
|
|
|
-- Calculate the number of lines in contentText using string.gsub
|
|
local _, numLines = string.gsub(contentText, "\n", "")
|
|
numLines = numLines + 2 -- Add lines for title and padding
|
|
|
|
-- Adjust tooltip height based on the number of lines
|
|
local lineHeight = 10
|
|
local totalHeight = 50 + (numLines * lineHeight)
|
|
tooltipFrame:SetHeight(totalHeight)
|
|
|
|
-- Set the width based on content
|
|
local maxWidth = math.max(tooltipFrame.title:GetStringWidth() + 70, tooltipFrame.content:GetStringWidth() +20)
|
|
tooltipFrame:SetWidth(maxWidth)
|
|
|
|
-- Position the tooltip near the cursor
|
|
local x, y = GetCursorPosition()
|
|
local scale = UIParent:GetEffectiveScale()
|
|
tooltipFrame:SetPoint("BOTTOMLEFT", UIParent, "BOTTOMLEFT", x / scale + 10, y / scale - 10)
|
|
|
|
tooltipFrame:Show()
|
|
end
|
|
|
|
|
|
function ConsumeTracker_ShowOptionsTooltip(itemID)
|
|
-- Set the maximum width for the description text
|
|
local maxDescriptionWidth = 160
|
|
|
|
-- Create or reuse the tooltip frame
|
|
if not ConsumeTracker_OptionsTooltip then
|
|
-- Create the frame
|
|
local tooltipFrame = CreateFrame("Frame", "ConsumeTracker_OptionsTooltip", UIParent)
|
|
tooltipFrame:SetFrameStrata("TOOLTIP")
|
|
tooltipFrame:SetBackdrop({
|
|
bgFile = "Interface\\Tooltips\\UI-Tooltip-Background",
|
|
edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
|
|
tile = true, tileSize = 16, edgeSize = 16,
|
|
insets = { left = 4, right = 4, top = 4, bottom = 4 }
|
|
})
|
|
tooltipFrame:SetBackdropColor(0, 0, 0, 1)
|
|
|
|
-- Item icon
|
|
local icon = tooltipFrame:CreateTexture(nil, "ARTWORK")
|
|
icon:SetWidth(32)
|
|
icon:SetHeight(32)
|
|
icon:SetPoint("TOPLEFT", tooltipFrame, "TOPLEFT", 10, -10)
|
|
tooltipFrame.icon = icon
|
|
|
|
-- Item name
|
|
local title = tooltipFrame:CreateFontString(nil, "OVERLAY", "GameFontNormal")
|
|
title:SetPoint("TOPLEFT", icon, "TOPRIGHT", 10, -2)
|
|
title:SetJustifyH("LEFT")
|
|
tooltipFrame.title = title
|
|
|
|
-- Item description
|
|
local description = tooltipFrame:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
|
|
description:SetPoint("TOPLEFT", icon, "TOPRIGHT", 10, -16)
|
|
description:SetWidth(maxDescriptionWidth)
|
|
description:SetJustifyH("LEFT")
|
|
description:SetTextColor(1, 1, 1)
|
|
tooltipFrame.description = description
|
|
|
|
ConsumeTracker_OptionsTooltip = tooltipFrame
|
|
end
|
|
|
|
local tooltipFrame = ConsumeTracker_OptionsTooltip
|
|
|
|
-- Get item info
|
|
local itemName = consumablesList[itemID] or "Unknown Item"
|
|
local itemTexture = consumablesTexture[itemID] or "Interface\\Icons\\INV_Misc_QuestionMark"
|
|
local itemDescription = consumablesDescription[itemID] or ""
|
|
|
|
-- Function to add line breaks manually
|
|
local function WrapText(text, maxWidth, fontObject)
|
|
local wrappedText = ""
|
|
local currentLine = ""
|
|
local space = " "
|
|
local testString = tooltipFrame:CreateFontString(nil, "OVERLAY", fontObject)
|
|
testString:SetWidth(0)
|
|
testString:SetHeight(0)
|
|
testString:Hide() -- We don't need to display this
|
|
|
|
-- Replace \n with spaces to avoid unintended line breaks
|
|
text = string.gsub(text, "\n", " ")
|
|
|
|
-- Split the text into words
|
|
for word in string.gfind(text, "%S+") do
|
|
local testLine = currentLine == "" and word or (currentLine .. space .. word)
|
|
testString:SetText(testLine)
|
|
if testString:GetStringWidth() > maxWidth then
|
|
wrappedText = wrappedText == "" and currentLine or (wrappedText .. "\n" .. currentLine)
|
|
currentLine = word
|
|
else
|
|
currentLine = testLine
|
|
end
|
|
end
|
|
wrappedText = wrappedText == "" and currentLine or (wrappedText .. "\n" .. currentLine)
|
|
return wrappedText
|
|
end
|
|
|
|
-- Wrap the description text
|
|
local wrappedDescription = WrapText(itemDescription, maxDescriptionWidth, "GameFontNormalSmall")
|
|
|
|
-- Set icon, title, and description
|
|
tooltipFrame.icon:SetTexture(itemTexture)
|
|
tooltipFrame.title:SetText(itemName)
|
|
tooltipFrame.description:SetText(wrappedDescription)
|
|
|
|
-- Calculate the number of lines in the wrapped description
|
|
local _, lineCount = string.gsub(wrappedDescription, "\n", "")
|
|
lineCount = lineCount + 1 -- Add 1 for the last line
|
|
|
|
-- Set the heights for the description and the tooltip frame
|
|
local lineHeight = 12
|
|
tooltipFrame.description:SetHeight(lineCount * lineHeight)
|
|
|
|
local totalHeight = 50 + (lineCount * lineHeight)
|
|
tooltipFrame:SetHeight(totalHeight)
|
|
|
|
-- Set the width of the tooltip
|
|
local maxWidth = math.max(tooltipFrame.title:GetStringWidth() + 70, tooltipFrame.description:GetStringWidth() + 70)
|
|
tooltipFrame:SetWidth(maxWidth)
|
|
|
|
-- Position the tooltip near the cursor
|
|
local x, y = GetCursorPosition()
|
|
local scale = UIParent:GetEffectiveScale()
|
|
tooltipFrame:SetPoint("BOTTOMLEFT", UIParent, "BOTTOMLEFT", x / scale + 10, y / scale - 10)
|
|
|
|
tooltipFrame:Show()
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
-- Function to scan player's inventory
|
|
function ConsumeTracker_ScanPlayerInventory()
|
|
local playerName = UnitName("player")
|
|
local realmName = GetRealmName()
|
|
local faction = UnitFactionGroup("player")
|
|
|
|
ConsumeTracker_Data[realmName] = ConsumeTracker_Data[realmName] or {}
|
|
ConsumeTracker_Data[realmName][faction] = ConsumeTracker_Data[realmName][faction] or {}
|
|
ConsumeTracker_Data[realmName][faction][playerName] = ConsumeTracker_Data[realmName][faction][playerName] or {}
|
|
local data = ConsumeTracker_Data[realmName][faction][playerName]
|
|
data["inventory"] = {}
|
|
|
|
for bag = 0, 4 do
|
|
local numSlots = GetContainerNumSlots(bag)
|
|
if numSlots then
|
|
for slot = 1, numSlots do
|
|
local link = GetContainerItemLink(bag, slot)
|
|
if link then
|
|
local _, _, itemID = string.find(link, "item:(%d+)")
|
|
if itemID then
|
|
itemID = tonumber(itemID)
|
|
if ConsumeTracker_Settings[itemID] then
|
|
local texture, itemCount = GetContainerItemInfo(bag, slot)
|
|
data["inventory"][itemID] = (data["inventory"][itemID] or 0) + itemCount
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
ConsumeTracker_UpdateTrackerContent()
|
|
end
|
|
|
|
-- Function to scan player's bank
|
|
function ConsumeTracker_ScanPlayerBank()
|
|
|
|
if not BankFrame or not BankFrame:IsShown() then
|
|
return
|
|
end
|
|
|
|
local playerName = UnitName("player")
|
|
local realmName = GetRealmName()
|
|
local faction = UnitFactionGroup("player")
|
|
|
|
local data = ConsumeTracker_Data[realmName][faction][playerName]
|
|
data["bank"] = {}
|
|
|
|
-- Bank bags are -1 and 5 to 10 in WoW 1.12
|
|
for bag = -1, 10 do
|
|
if bag == -1 or (bag >= 5 and bag <= 10) then
|
|
local numSlots = GetContainerNumSlots(bag)
|
|
if numSlots then
|
|
for slot = 1, numSlots do
|
|
local link = GetContainerItemLink(bag, slot)
|
|
if link then
|
|
local _, _, itemID = string.find(link, "item:(%d+)")
|
|
if itemID then
|
|
itemID = tonumber(itemID)
|
|
if ConsumeTracker_Settings[itemID] then
|
|
local texture, itemCount = GetContainerItemInfo(bag, slot)
|
|
data["bank"][itemID] = (data["bank"][itemID] or 0) + itemCount
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
ConsumeTracker_UpdateTrackerContent()
|
|
end
|
|
|
|
-- Function to scan player's mail
|
|
function ConsumeTracker_ScanPlayerMail()
|
|
if not MailFrame or not MailFrame:IsShown() then
|
|
return
|
|
end
|
|
|
|
local playerName = UnitName("player")
|
|
local realmName = GetRealmName()
|
|
local faction = UnitFactionGroup("player")
|
|
|
|
-- Ensure data tables are initialized
|
|
ConsumeTracker_Data[realmName] = ConsumeTracker_Data[realmName] or {}
|
|
ConsumeTracker_Data[realmName][faction] = ConsumeTracker_Data[realmName][faction] or {}
|
|
ConsumeTracker_Data[realmName][faction][playerName] = ConsumeTracker_Data[realmName][faction][playerName] or {}
|
|
local data = ConsumeTracker_Data[realmName][faction][playerName]
|
|
data["mail"] = {}
|
|
|
|
local numInboxItems = GetInboxNumItems()
|
|
if numInboxItems and numInboxItems > 0 then
|
|
for mailIndex = 1, numInboxItems do
|
|
local itemName, itemTexture, itemCount, itemQuality = GetInboxItem(mailIndex)
|
|
if itemName and itemCount and itemCount > 0 then
|
|
-- Since GetInboxItemLink is not available, use itemName to get itemID
|
|
local itemID = consumablesNameToID[itemName]
|
|
if itemID and ConsumeTracker_Settings[itemID] then
|
|
data["mail"][itemID] = (data["mail"][itemID] or 0) + itemCount
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
ConsumeTracker_UpdateTrackerContent()
|
|
end
|
|
|